{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Write a driver for hls ip\n",
    "给hls ip写一个上层驱动"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from pynq import DefaultIP\n",
    "\n",
    "class FirDriver(DefaultIP):\n",
    "    def __init__(self, description):\n",
    "        super().__init__(description=description)\n",
    "    \n",
    "    bindto = ['xilinx.com:hls:fir:1.0']\n",
    "    \n",
    "    @property\n",
    "    def x(self):\n",
    "        return self.read(0x10)\n",
    "    \n",
    "    @x.setter\n",
    "    def x(self, value):\n",
    "        self.write(0x10, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import Overlay\n",
    "导入Overlay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "\n",
       "require(['notebook/js/codecell'], function(codecell) {\n",
       "  codecell.CodeCell.options_default.highlight_modes[\n",
       "      'magic_text/x-csrc'] = {'reg':[/^%%microblaze/]};\n",
       "  Jupyter.notebook.events.one('kernel_ready.Kernel', function(){\n",
       "      Jupyter.notebook.get_cells().map(function(cell){\n",
       "          if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n",
       "  });\n",
       "});\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pynq.lib.dma\n",
    "import numpy as np\n",
    "\n",
    "firol = pynq.Overlay(\"fir.bit\")"
   ]
  },
  {
   "attachments": {
    "Diagram.JPG": {
     "image/jpeg": "/9j/4AAQSkZJRgABAQEAeAB4AAD/4RDaRXhpZgAATU0AKgAAAAgABAE7AAIAAAAFAAAISodpAAQAAAABAAAIUJydAAEAAAAKAAAQyOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlbGwAAAAFkAMAAgAAABQAABCekAQAAgAAABQAABCykpEAAgAAAAM5NgAAkpIAAgAAAAM5NgAA6hwABwAACAwAAAiSAAAAABzqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjAxOTowMzoxNCAxMTozMjoxOQAyMDE5OjAzOjE0IDExOjMyOjE5AAAAZABlAGwAbAAAAP/hCxdodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkJz8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIj48cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIi8+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRlRGF0ZT4yMDE5LTAzLTE0VDExOjMyOjE5Ljk1NzwveG1wOkNyZWF0ZURhdGU+PC9yZGY6RGVzY3JpcHRpb24+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iPjxkYzpjcmVhdG9yPjxyZGY6U2VxIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpsaT5kZWxsPC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIA1QDEAMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APpGiuf8ff8AJNvE3/YJuv8A0S1H/CA+Dv8AoU9D/wDBbD/8TTEdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNH/AAgPg7/oU9D/APBbD/8AE0aBqdBRXP8A/CA+Dv8AoU9D/wDBbD/8TR/wgPg7/oU9D/8ABbD/APE0aBqdBRXP/wDCA+Dv+hT0P/wWw/8AxNZ2t6B8PPDlkl3rPhzQ7aB5BEr/ANlRvliCcYVCegNNK7sgbtqzsaK8x/tT4O/9AvQ//BJ/9qo/tT4O/wDQL0P/AMEn/wBqrT2NT+V/cR7SPdfeenUV5j/anwd/6Beh/wDgk/8AtVH9qfB3/oF6H/4JP/tVHsan8r+4PaR7r7z06ivMf7U+Dv8A0C9D/wDBJ/8AaqP7U+Dv/QL0P/wSf/aqPY1P5X9we0j3X3np1FeY/wBqfB3/AKBeh/8Agk/+1Uf2p8Hf+gXof/gk/wDtVHsan8r+4PaR7r7z06ivMf7U+Dv/AEC9D/8ABJ/9qo/tT4O/9AvQ/wDwSf8A2qj2NT+V/cHtI91956dRXmP9qfB3/oF6H/4JP/tVH9qfB3/oF6H/AOCT/wC1Uexqfyv7g9pHuvvPTqK8x/tT4O/9AvQ//BJ/9qo/tT4O/wDQL0P/AMEn/wBqo9jU/lf3B7SPdfeenUV5j/anwd/6Beh/+CT/AO1Uf2p8Hf8AoF6H/wCCT/7VR7Gp/K/uD2ke6+89OorzH+1Pg7/0C9D/APBJ/wDaqP7U+Dv/AEC9D/8ABJ/9qo9jU/lf3B7SPdfeenUV5j/anwd/6Beh/wDgk/8AtVH9qfB3/oF6H/4JP/tVHsan8r+4PaR7r7z06ivMf7U+Dv8A0C9D/wDBJ/8AaqP7U+Dv/QL0P/wSf/aqPY1P5X9we0j3X3np1FeY/wBqfB3/AKBeh/8Agk/+1Uf2p8Hf+gXof/gk/wDtVHsan8r+4PaR7r7z06ivMf7U+Dv/AEC9D/8ABJ/9qo/tT4O/9AvQ/wDwSf8A2qj2NT+V/cHtI91956dRXmP9qfB3/oF6H/4JP/tVH9qfB3/oF6H/AOCT/wC1Uexqfyv7g9pHuvvPTqK8x/tT4O/9AvQ//BJ/9qo/tT4O/wDQL0P/AMEn/wBqo9jU/lf3B7SPdfeenUV5j/anwd/6Beh/+CT/AO1Uf2p8Hf8AoF6H/wCCT/7VR7Gp/K/uD2ke6+89OorzH+1Pg7/0C9D/APBJ/wDaqP7U+Dv/AEC9D/8ABJ/9qo9jU/lf3B7SPdfeenUV5j/anwd/6Beh/wDgk/8AtVH9qfB3/oF6H/4JP/tVHsan8r+4PaR7r7z06ivMf7U+Dv8A0C9D/wDBJ/8AaqP7U+Dv/QL0P/wSf/aqPY1P5X9we0j3X3np1FeY/wBqfB3/AKBeh/8Agk/+1Uf2p8Hf+gXof/gk/wDtVHsan8r+4PaR7r7z06ivMf7U+Dv/AEC9D/8ABJ/9qo/tT4O/9AvQ/wDwSf8A2qj2NT+V/cHtI91956dRXmP9qfB3/oF6H/4JP/tVH9qfB3/oF6H/AOCT/wC1Uexqfyv7g9pHuvvPTqK4LRLT4X+I717TRtC0O5nSMysn9jqmFBAzlowOpFbv/CA+Dv8AoU9D/wDBbD/8TUSi4u0tCk76o6Ciub8B28Np4Xkt7WKOCCHVNRjjijUKqKL2YBQBwABxiukqXuUgooopAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAc/4+/5Jt4m/7BN1/wCiWroK5/x9/wAk28Tf9gm6/wDRLVoa5q6aHpZvZLae6/fQwJDb7d8jyyrGgG9lX7zjkkU+gupoUVz/APwkeqf9CXrn/f6x/wDkmj/hI9U/6EvXP+/1j/8AJNFgudBRXP8A/CR6p/0Jeuf9/rH/AOSaP+Ej1T/oS9c/7/WP/wAk0WC50FFc/wD8JHqn/Ql65/3+sf8A5Jo/4SPVP+hL1z/v9Y//ACTRYLnQUVz/APwkeqf9CXrn/f6x/wDkmj/hI9U/6EvXP+/1j/8AJNFgudBRXP8A/CR6p/0Jeuf9/rH/AOSaP+Ej1T/oS9c/7/WP/wAk0WC50FFc/wD8JHqn/Ql65/3+sf8A5Jo/4SPVP+hL1z/v9Y//ACTRYLnQUVz/APwkeqf9CXrn/f6x/wDkmj/hI9U/6EvXP+/1j/8AJNFgudBRXP8A/CR6p/0Jeuf9/rH/AOSaP+Ej1T/oS9c/7/WP/wAk0WC50FFc/wD8JHqn/Ql65/3+sf8A5Jo/4SPVP+hL1z/v9Y//ACTRYLnQUVz/APwkeqf9CXrn/f6x/wDkmj/hI9U/6EvXP+/1j/8AJNFgudBRXP8A/CR6p/0Jeuf9/rH/AOSaP+Ej1T/oS9c/7/WP/wAk0WC50FFc/wD8JHqn/Ql65/3+sf8A5Jo/4SPVP+hL1z/v9Y//ACTRYLnQUVz/APwkeqf9CXrn/f6x/wDkmj/hI9U/6EvXP+/1j/8AJNFgudBRXP8A/CR6p/0Jeuf9/rH/AOSaP+Ej1T/oS9c/7/WP/wAk0WC50FFc/wD8JHqn/Ql65/3+sf8A5Jo/4SPVP+hL1z/v9Y//ACTRYLnQUVj6R4gOqald6fcaTfaZdWsMU7R3ZhbekhkVSDFI46xPkHHatikMK86+Nn/Il2n/AGEE/wDRclei1518bP8AkS7T/sIJ/wCi5K6MN/GiZVfgZc8WXPgvwd9k/tPwzay/a9+z7PYQtjbtznOP7wrnP+E/+HP/AEKX/lNt/wD4qtf4kf8AI6eB/wDsIH/0ZDXotac0YQi5Xbfn5k2bk0unkeR/8J/8Of8AoUv/ACm2/wD8VR/wn/w5/wChS/8AKbb/APxVeuUVPtofyv7/APgD9nLv+B5H/wAJ/wDDn/oUv/Kbb/8AxVH/AAn/AMOf+hS/8ptv/wDFV65RR7aH8r+//gB7OXf8DyP/AIT/AOHP/Qpf+U23/wDiqP8AhP8A4c/9Cl/5Tbf/AOKr1yij20P5X9//AAA9nLv+B5H/AMJ/8Of+hS/8ptv/APFUf8J/8Of+hS/8ptv/APFV65RR7aH8r+//AIAezl3/AAPI/wDhP/hz/wBCl/5Tbf8A+Ko/4T/4c/8AQpf+U23/APiq9coo9tD+V/f/AMAPZy7/AIHkf/Cf/Dn/AKFL/wAptv8A/FUf8J/8Of8AoUv/ACm2/wD8VXrlFHtofyv7/wDgB7OXf8DyP/hP/hz/ANCl/wCU23/+Ko/4T/4c/wDQpf8AlNt//iq9coo9tD+V/f8A8APZy7/geR/8J/8ADn/oUv8Aym2//wAVR/wn/wAOf+hS/wDKbb//ABVeuUUe2h/K/v8A+AHs5d/wPI/+E/8Ahz/0KX/lNt//AIqj/hP/AIc/9Cl/5Tbf/wCKr1yij20P5X9//AD2cu/4Hkf/AAn/AMOf+hS/8ptv/wDFUf8ACf8Aw5/6FL/ym2//AMVXrlFHtofyv7/+AHs5d/wPI/8AhP8A4c/9Cl/5Tbf/AOKo/wCE/wDhz/0KX/lNt/8A4qvXKKPbQ/lf3/8AAD2cu/4Hkf8Awn/w5/6FL/ym2/8A8VR/wn/w5/6FL/ym2/8A8VXrlFHtofyv7/8AgB7OXf8AA8j/AOE/+HP/AEKX/lNt/wD4qj/hP/hz/wBCl/5Tbf8A+Kr1yij20P5X9/8AwA9nLv8AgeR/8J/8Of8AoUv/ACm2/wD8VR/wn/w5/wChS/8AKbb/APxVeuUUe2h/K/v/AOAHs5d/wPI/+E/+HP8A0KX/AJTbf/4qj/hP/hz/ANCl/wCU23/+Kr1yij20P5X9/wDwA9nLv+B5H/wn/wAOf+hS/wDKbb//ABVH/Cf/AA5/6FL/AMptv/8AFV65RR7aH8r+/wD4Aezl3/A8j/4T/wCHP/Qpf+U23/8AiqP+E/8Ahz/0KX/lNt//AIqvXKKPbQ/lf3/8APZy7/geR/8ACf8Aw5/6FL/ym2//AMVR/wAJ/wDDn/oUv/Kbb/8AxVeuUUe2h/K/v/4Aezl3/A8j/wCE/wDhz/0KX/lNt/8A4qj/AIT/AOHP/Qpf+U23/wDiq9coo9tD+V/f/wAAPZy7/geR/wDCf/Dn/oUv/Kbb/wDxVH/Cf/Dn/oUv/Kbb/wDxVeuUUe2h/K/v/wCAHs5d/wADyP8A4T/4c/8AQpf+U23/APiq0dA8SeAvEeuW+lWXhaKOe43bWm06AKNqljkgk9Ae1el151rP/Jf/AA//ANg9/wD0GerjOE7pJrR9SXGUbX/Ih8N2ltY/HbXbayt4raBNPXbFCgRVyICcAcDkk16XXnWjf8l/8Qf9g9P/AEGCvRayxG8fRfkXT2fqzn/BX/IBuf8AsLal/wCl09dBXP8Agr/kA3P/AGFtS/8AS6eugrB7mi2CiiikMKKKKACiiigAooooAKKKKACiiigAooooA5/x9/yTbxN/2Cbr/wBEtR41/wCQDbf9hbTf/S6Cjx9/yTbxN/2Cbr/0S1HjX/kA23/YW03/ANLoKpdBM6CiiipGFFFFABRRRQAUUUUAFFFFABTIpo503wyLImSu5GBGQcEfgQR+FebP4b8SWslhcW0V9Pc+fJJOst+Wiz9oypP75Sn7sKMqHG3KlOx3/DVxp3hTR20zWbu10y4W6uJFjuryMGSNpnKSLlidpBHXB4ORQB1tZ+p+ING0VgNY1axsCylwLq4SPKjqfmI4rz7RrTV9W0W4udOj1RI5ra8jkn/tBWN1IbhfKMWXO3aiyDnZwwGf4ht6bo+tXOk6Xp2rWvl2qahJPdhpcl4Uy0SlTJJgGTYdodhtTHAO0AHZzTxW9vJPcSpFDGpd5HYKqKBkkk8AAd6isNQs9UtRc6bdQ3cDEgSQuHXI6jI7j0rA17UdO8R6Dd6bomqWN7euoeO2hu42aXYwYp1/iCkZPHPNGl3sGj3GrXmvywaP/al/59vBeXMavtWCGIk4YrnMZPBPBXPOaAOiN1ALxbQzR/aGjMoi3DcUBALY9MkDPvWd/wAJX4e+xNef25p32ZZBE032pNgcjO3OcZwCfpz0rLvNGi1bWn1PRvs+y+0m6tn1CBlO52MQj5HJACNjHAwfWsO00nW4PFFjr7aBOIrXTobBrFZ4PMLKsxMi/vNm0eYEGSG5bjFAHexalYz3z2cF5BJdRxLM8KSAuqNnaxHXBwcHvinWV9aalZR3mnXMN1bSjMc0Dh0cZxkEcGvM7fwT4hsJrV7SFVm/smz0eeeOZRtiMTLM6ZOSUdY2GeSM4zzXb+DtLl0XwrbWFxALdoZJsRKQQqmVyuMcfdIoA3KKKKACiiigAooooAKKKKACiiigDn7P/kpOs/8AYJsP/R15XQVz9n/yUnWf+wTYf+jryugpsSCvOvjZ/wAiXaf9hBP/AEXJXotedfGz/kS7T/sIJ/6LkrfDfxomdX4GHxI/5HTwP/2ED/6Mhr0WvOviR/yOngf/ALCB/wDRkNei0VP4cPn+Y4/FL+ugUUUVzmgUUUUAFFFFABRRRQAUUUUAFFYkvieEXE0dnYXd6kLFGmhaJULg4ZQXdckd8cDpnPFIniK4kGY/D2psOmVltT/7Wq/ZyJ5kblcx408RS6DDZJb3EdvJdSOoeREIwqE9XkRRzjuSRnA7i7/b93/0Lmqf9/LX/wCPUf2/d/8AQt6p/wB/LX/49R7OQcyORi8ealerpJP2WK31HS4Lu4kCP/o00kDOLfcD1fAKknICkHl0zvX+pzRfCtdSX/XHTopf9Y45KqfvBt3frnPvWh/b93/0Lmqf9/LX/wCPVnrIVvvtY0HxF5m8vtOqKUznP3PtO3HtjHtR7OQcyOb8YeKvEFrp+pta3kFvD9uuLCMpCRJCI7R7jzd+7r+7I6Dg57Vbh8c6nL4lnsVNs0cck0YT5NxjSAyLOMSFyGIX+ALtcYbI+bqf7fu/+hc1T/v5a/8Ax6j+37v/AKFvVP8Av5a//HqPZyDmRydr4z1mOFX1C+083X2WC4hsFtWEl+ZUL4jAckAH5QcHGxi3HR9t4y1W6jWKy1HTb4zPYD7bbwExwtO7q8RUOcsoUMBnIDDd2J6n+37v/oW9U/7+Wv8A8eo/t+7/AOhb1T/v5a//AB6j2cg5kcjp/jTX55rl55bIxafqkGnSotswM+++e0L53/LwocDB5yOlVYPiLrFxeLFKbOzjlkZLiSZUP9m4mCDeFlJ5BK5cJ82CARkDuP7fu/8AoXNU/wC/lr/8eo/t67/6FvVP+/lr/wDHqPZyDmRk+FdXutR8Vailxq8N7D9ht5IEhjMaON8yNKikk7SUHIyDxgkYqj4/vpLW6ud9/PZvHpE02lLFcNEZ7wNwoUECRh+7AQ5zvIxya273UJdQhWKfw9riKrbgbe8hhbP1S4BI56dKWz1Kaxt/Jh8Pa2653Znu4Zm/76e4J/DNHs5BzI6KisX+37v/AKFzVP8Av5a//HqP7fu/+hc1T/v5a/8Ax6j2cg5kbVFYw167LAHw7qg56mS24/8AI1WdM1iHU2mi8ma1uYCPNtrgKHQHo3ykgg4OCCRwR1BocJJXBSTNCiiioKCiiigAooooAKKKKACiiigAooooAK861n/kv/h//sHv/wCgz16LXnWs/wDJf/D/AP2D3/8AQZ66KG8vR/kZ1Nl6oNG/5L/4g/7B6f8AoMFei151o3/Jf/EH/YPT/wBBgr0WivvH0X5Cp7P1Zz/gr/kA3P8A2FtS/wDS6eugrjtMuprH4c67d2r+XPb3WsSxvgHay3dwQcHg8iua0BviZ4j0O31Wy8RWEcFxu2rNCgYbWKnIERHUHvSjSc05XSXmNztZWPVqxfEnivTfCsNvJqpmxcyeXGIYy5LemBXKf2N8Vf8AoZdL/wC/a/8AxmsHX7bxXp2u+H5fGesWV3bm8Ii8kBdjbeSTsX+tP2KWvMn/AF6EyqO2isda/wAWPD0aF3i1JVUZLGyYACus03UrTV9OhvtOnWe2mXckinr/AIH27Vx8mq6ckbNJfWqooJYmZcAfnWZ8Nbe7k8QajqGiK1r4YmJCxSjieXoXiH8K/wD6v93FWabtYptxkle9zvdS1/R9GkSPV9Us7F5FLotzOsZZR1IyegyOfeorjxToFpOkN3renwSyIkiJJdIpZW+6Rk9D2Pes3WBqVl41s9Us9Fu9Utxp81s/2WWBSjtJGwyJZE4wp6ZrmdL0PXtCtdTsG8Oyaguo6bHApingFvC2ZiYm3uG2L5qrlUPA4HapNDur/wAS6Hpd01vqesWNnMqB2jnuURlU5wSCeBwefatMEEZHINed3vgzxAyaoljqlxEW0q0tUAMWy/aNZBIjllZ03BsblII3Z5xXeWChNNtkW2a1CxKBbsQTFwPlJBIOOnBI460AWKKKKACiiigAooooA5/x9/yTbxN/2Cbr/wBEtR41/wCQDbf9hbTf/S6Cjx9/yTbxN/2Cbr/0S1HjX/kA23/YW03/ANLoKpdBM6Ciiq93qFnYKrX93BbKxwpmkCAn2zUjM3Vb7UH1JNM0looXMPnT3MqF/KUnChV4BY4bqcDb0NRnTtRJz/wkepD2EVtgf+Qahs721v8AxfqMtjcw3MYsLVS8MgcA+ZccZHfkVNN4g0yG6+zm7ieUSiJ0RwSh55PoBggnsa6NEkjJ3bE/s3Uf+hk1P/v1a/8Axmj+zdR/6GTU/wDv1a//ABmnR6/pEsHnR6naGPn5vOXHBUevq6f99r6inf23pf2jyDqNr5oVmK+cuQFznv22t/3yfQ0X9PuQiP8As3Uf+hk1P/v1a/8Axmj+zdR/6GTU/wDv1a//ABmnWmu6bf3wtLK7jnl8oy4Q5wobaf17VJLrGnQXn2Se+t47jj928gBySAB9Tkce49aL+n3ICH+zdR/6GTU/+/Vr/wDGaP7N1H/oZNT/AO/Vr/8AGakXXNKa8+yrqNqbjLDyxMu4Fc7hjPUbW4/2T6GprLULTUrfz9PuYrmIHaXiYMAeuPyIP0INF/T7kBV/s3Uf+hk1P/v1a/8Axmj+zdR/6GTU/wDv1a//ABmobjxXpEEnlpdLcMGKsICH2EEDnn1OPwPpWrBPFdQJPbSpNFINySIwZWHqCOoov6fcgKH9m6j/ANDJqf8A36tf/jNH9m6j/wBDJqf/AH6tf/jNadFF/L8EBmf2bqP/AEMmp/8Afq1/+M0f2bqP/Qyan/36tf8A4zWnRRfy/BAZn9m6j/0Mmp/9+rX/AOM0f2bqP/Qyan/36tf/AIzWnRRfy/BAZn9m6j/0Mmp/9+rX/wCM0f2bqP8A0Mmp/wDfq1/+M1p0UX8vwQGZ/Zuo/wDQyan/AN+rX/4zR/Zuo/8AQyan/wB+rX/4zWnUVxcw2lu891NHDCgy0kjBVX6k0X8vwQFH+zdR/wChk1P/AL9Wv/xmj+zdR/6GTU/+/Vr/APGagfxboawiVNSglTzEjZo3DbC24Dd6cqw+oI6itKS/tIrD7dJdQrabBJ55kGzaejbumDnrRzen3ICp/Zuo/wDQyan/AN+rX/4zR/Zuo/8AQyan/wB+rX/4zThr+kkyAajbZiQO480ZUHHP/jy/99D1FQ3XirQ7SDzZdTtipQOoWQEsCeMD8D+R9DRzen3IBLmfVtEj+1tfHUrOPBuEuYkWVVz8zq0agcDnBXnHUV0lc74q/wCRO1n/AK8J/wD0W1acOu6RczLDb6pZSyucKkdwjMx9gDUVLWTKhvYv0UUVkaHP2f8AyUnWf+wTYf8Ao68roK5+z/5KTrP/AGCbD/0deV0FNiQV518bP+RLtP8AsIJ/6Lkr0WvOvjZ/yJdp/wBhBP8A0XJW+G/jRM6vwMPiR/yOngf/ALCB/wDRkNei15Z4/wBc0m88XeDprPVLK4it74vM8VwjLEvmRHLEHgcHr6Gu8/4S3w5/0H9L/wDA2P8AxqqkZezhp3/MUZLmka9FZH/CW+HP+g/pf/gbH/jR/wAJb4c/6D+l/wDgbH/jWHJLsa8y7mvRWR/wlvhz/oP6X/4Gx/40f8Jb4c/6D+l/+Bsf+NHJLsHMu5r0Vkf8Jb4c/wCg/pf/AIGx/wCNH/CW+HP+g/pf/gbH/jRyS7BzLua9FZH/AAlvhz/oP6X/AOBsf+NH/CW+HP8AoP6X/wCBsf8AjRyS7BzLua9FZH/CW+HP+g/pf/gbH/jWXJc6zd6o1xpmoSyabJd27RGGC3eMw7T5gDl9xUnGWxuH8IYZpqnJ76EuaXmeS69b6TdeLvCMevzNBZy6TZtKVQbXLSEtvbeuxTliXGSOuKvfBdoY/GWqQafc3E1m1mGBmjERchl5KBmGRuYDk8HtnFbPiIeE4fh/o99r9la6hqNtplt5FobwwTSIwUfwncQPmPQgYbpk12XhPSfDOm2cz+EVtWhlfEslvP52WA+6WJJ4BzjPf3r0J1Pca1/Q5ox946CisGDxdZXEV1KlvdeVAxjVwqsJnD+XsGGO1ixACvtJz7HDrHxVZahepbQw3Cs0z2zM6DbHOoZmhOCfmARjkZXGOeRniNzcorP1nWbTQrD7XflhFvC/IuT6k49FUMx9FUmoW8R2SanPp7LN9qt1aSWPZ92MLu8z/dOdoPdsj+FsAjWoqCyu47/T7e8g3eVcRLKm4YO1hkZ/Op6ACiiigAooooAKKKKACiiigArOGF8a2W0AGTT7nccddskGPy3N+daNZx/5HTT/APsH3f8A6Mt6a6gbtFFFc5sFFFFABRRRQAUUUUAFFFFABRRRQAV51rP/ACX/AMP/APYPf/0GevRa861n/kv/AIf/AOwe/wD6DPXRQ3l6P8jOpsvVBo3/ACX/AMQf9g9P/QYK9FrzrRv+S/8AiD/sHp/6DBXotFfePovyFT2fqziLf/klniT/AK7a1/6VXFWfhZ/yTXSv+23/AKOeq1v/AMks8Sf9dta/9Kriua/5tq/z/wA/lXCPPT5e8l+pLdpX8j1yuG+JlzFHDpFs+i2mryXVyY4o7pyqodvXIrF0P4Q6Bqfh7Tr+e71JZbq1imcJLGFDMgJxlOnNZviTwTp3gbUtF1LTP7Su1+1HzwQJCqgdQFUUuSnF6Su/T/ginKTjqtBj6PcpGzDwBoTkDO1blsn2616R4O8Sad4g0ZRYQizltAIZ7Aja1sw4249OOD/9cVxb+ObBY2ZbDVHIGQosmyfbmtbwP4Yvn1qbxbrkZs7u6j8uCyj+Xy4uxk/vN04PT8gMXzNe8OKjGS9m7nTan4gNhrNvplvpl3f3M1u9wBA0ShUVlU5LuvOXHTNV5vGVja/aWvoJ7WGzvUsrqeTZst3eGOVWchuE/eom7sx9Oak1Pwrp+seIrbU9Ut7a8jt7SS3W3ubdZBl3Rt4LdCNmOnfrVS88FpqE+ox3l55mm6nfreXdn5WPOVbeKJYi277mYgx45yF6Z3Zm48eMRLPZQ2ejahcSXlvJdRr+6jIiVwoYh3XG7cpA64PIB4qP/hN40Ny9xo2ow2tncJbXV0TCyQOyoSWAkLFR5igkAgcnoM1QvfAN7dT6fNJqWm372NtLaodX0k3e6NnVkJ/er84VApb+Lk4GafH4J1Qw3tjcazY/2XqE6T3Vvb6Y0TnCRqyI5mYKh8vGNpIBIznmgDp9a1SHQ9Bv9WukkeCxtpLmRYwCzKiliBkgZwPWsnUPGEdlLfPHpd7dWOmsVvr2Hy9kJChmwpYM+1SC20H0GSCA7X47rxBo2qaAdLvraPULeaz+3EwOkYdSnmbfN3Ec5xgH6VDfeFL2dNVtLLVo7bTdWZmuYWtS8qb1CyeXJvAXcBnlWwxJ54AAOmVg6hkIZWGQQcgilpscaQxJFGu1EUKoHYDpTqACiiigDn/H3/JNvE3/AGCbr/0S1bF9YWeqWUlnqdpBeWsmN8FxGJEfBBGVOQcEA/hWX42t5rv4f+Ibe1iknnm0u5jjijUszsYmAUAckk8YqP8A4TXS/wDn11z/AMEF9/8AGarW2guof8ID4O/6FPQ//BbD/wDE1Wvfhl4I1CFYrnwrpOxW3YitViyffaBnqetWf+E10v8A59dc/wDBBff/ABmsXxV8WNF8L6JLqE2n61MVVtkbaVcQBmAJALSooA45POKWoaFjw94Z0bwr4l1Ox8O6fDp9tJaWszRQggFy84LfXCgfhTrrwRpt7d3c1xPdFLtmMsCMiI24EHO1QScEjcSSBwDWD8PPGV94s8QanNq9la2lz9jtti2VyLiPy/mcZcdG/fAY9jXQN4xtUm1AGyvTBYxzSPceUBG4hYLJgkjkEnjvtb2zs+hmNvPBFhqVq8Oo3d5ctLMZpZWZFaTMQj2nagG35UbAA+ZFPtRD4I0yC4SWOSbKxBCGSJtxEJh37ihYMU64IBPbk5t6Hr39uTTmK2eK3WKGWGR2GZFkXcDgE44x+dU77xpBYyyodMv5zG8qgQRq5dYseYwAOcAso5wST+NLQNR9l4bfQWSbR3e7kCtEYrudYowhIPyhIjtwV4VQB8zd6i1Pwq2p/ar5m8m/ubZoHhSUCHJXaCXEYdsZyAeARkAdaVPG1s9q0gsLwTfaFgjtig81yyswO3OQNqMckYOOM1oeHdbOv6fJd/ZJbVBKURJhhyu0EFh2PPI7Yo0AqDwZpps47eV55I1ADAuBv/cPAcnGeVkYk5znmrkUGq2DCK3KajGxDPPe3XlyA9MBUi24wAe3JNU9P8WQ3t7a2otZz9ofyvP2qqhzG0gGNxP3Ubn1x68dDQBzcvgmwuLNLO7uru4tYovIjgkMZRIuPkxs5GABzkkdSa29Psl07T4bOKSSSOFdiNK25go6DPfAwMnnjkk5NWaKYBRRRQIKKKKACiuf1vxP/YepFLizkmtFgSSSWIruQtJ5Y4JGRkjp7/iy58Z2du3FrcuqzCKWQBQkWYo5NzMThRiVeTgZB9soZ0dFZ2t6uui2Auntp7kFwmyBckcE5PoOOvbvgc1j2vjaOeScPYTeVE+RLHJGymMlVVshuclu2eKYHU1Wv7GPUbJ7WcsqOVJKEA8MCOv0rGm8XRbLj7DYz3LWwk83540CbZZIR95hnLxN0ycD1IBvyawLfw5Hqs9vIS0MchhjILZbHyjJA6n1pAU28I2vmtLBeXkExm84SIUJVvNll4DIRjMzjkdAO/JdDpNydNj0Wa2hj02BEijmS7LTFYyNmVMYGTtGearjxnEWulGlai32dX5SHcHdHWN0UjqQzY467WI6DNO4+IUHkFrDTLu5YEIzKFMaSFdxRnBIBC9fcgdc4NAL7+C9Nee9k3yf6YJNymKFgvmOrvgshJBZc4YsOenTFX/hXum8n7ZelzyZH8p337CgcMyEghSAACFwBx1y3/hKr/8Ati6gEdt5FreQwsCrbnSWcQrg7sZUhmJxzlRgdattr1/Jrv2OKKGCNro2QEy7nEn2dpxJ8rYKYAG3qeeRjFGgF3xT/wAidrP/AF4T/wDotqq6Z8LfBOjanBqGl+G7K2u7dt8U0anch9RzUd9fPqnwuudQlVUe60Zp2VeiloSxA/OuI8J/tIaT4s8WadoVvoN7by30wiWV5kKqcZyQPpSn8K+f6Djuz2eiiisjQ5+z/wCSk6z/ANgmw/8AR15XQVz9n/yUnWf+wTYf+jryugpsSCs7W9A03xHZJaazbfaYEkEqp5jJhgCM5Ug9Ca0aKE2ndA0nozx3xt4L0DSPFHhW006w8mDULzyrlPOkbzF3xDGSxI4ZumOtdp/wqzwd/wBAf/yam/8Ai6wPizfR6Z4h8I386s0VrdPM4QAsVV4ScZ78VY/4XZ4c/wCfLVP+/Uf/AMcrvft504uDfX8zn/dxk1Kxr/8ACrPB3/QH/wDJqb/4uj/hVng7/oD/APk1N/8AF1kf8Ls8Of8APlqn/fqP/wCOUf8AC7PDn/Plqn/fqP8A+OVHJivP7yuaj5Gv/wAKs8Hf9Af/AMmpv/i6P+FWeDv+gP8A+TU3/wAXWR/wuzw5/wA+Wqf9+o//AI5R/wALs8Of8+Wqf9+o/wD45RyYrz+8Oaj5Gv8A8Ks8Hf8AQH/8mpv/AIuj/hVng7/oD/8Ak1N/8XWR/wALs8Of8+Wqf9+o/wD45R/wuzw5/wA+Wqf9+o//AI5RyYrz+8Oaj5Gv/wAKs8Hf9Af/AMmpv/i6P+FWeDv+gP8A+TU3/wAXWR/wuzw5/wA+Wqf9+o//AI5R/wALs8Of8+Wqf9+o/wD45RyYrz+8Oaj5Gv8A8Ks8Hf8AQH/8mpv/AIuqf2GHS9VNhYaCfs0F7aJHL/ZZl4Kt8/mmTLbOnmY+TOMNmqn/AAuzw5/z5ap/36j/APjlSwR6Zr96utwQSKLu8tLlfMsLgsCisFyyvs4yfmHyr0YEkU0qy/iXIk4P4LDJfB9j4s+HGmW8iW8F5Jp1qkd81sskkSqFbAPBweR1H3jXXWOm2OlwGHTbO3s4mbeY7eJY1LYAzgDrgD8q8817xde+Hfhrp0Wl2moJdHTLSRNQjtVe3hztBVmbIBIBGMfxL613Ohaz/bli9ydO1DTtshj8q/g8p2wAdwGTxzjPqDSqKVrva7HG1yh/whto11NcTXt5LM8flxyOY98QEiyKQwTLlWRcGQtjHucraeE4NNuPtdncXE0yzyXnkzSKsctw6upkYhMgkORxwAB8vFZ6eLNRR51uY7VXlGbRfLbbtMyRLJ5gZllQeYrMQUI4G3ni/pOvX15q9tZ3NvbiJ4bzfNGxBaS3uFh4Q/dUg7upPOO2ThoaE1zog194m8SWcOy33+XbxXLSxsWGCzZRTkDco7Yds9sRWfg2ys2jkW7vZblYTbvcSyKzyw7Ngjb5cbRgMMAHdk5+ZtzvFviJvDunRSW8IuLmaQiOHBO5VUu/A5yQu0HpuZc8VTj8Xtca5cWNqLaWGO1a9juVYlZY/LVlQf7YLhj6IUP8fymgHR2FnHp+m21lCWaO2iWJC5ySFAAz78VYqnpF4+o6JY3siqj3NvHMyr0BZQcD86uUxBRRRQAUUUUAFFFFABRRRQAVnH/kdNP/AOwfd/8Aoy3rRrOP/I6af/2D7v8A9GW9NAbtFFFc5sFFFFABRRRQAUUUUAFFFFABRRRQAV51rP8AyX/w/wD9g9//AEGevRa861n/AJL/AOH/APsHv/6DPXRQ3l6P8jOpsvVBo3/Jf/EH/YPT/wBBgr0WvOtG/wCS/wDiD/sHp/6DBXotFfePovyFT2fqziLf/klniT/rtrX/AKVXFc1/zbV/n/n8rpbf/klniT/rtrX/AKVXFc1/zbV/n/n8raj8K/xIie/yZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/ANFrWvXJP4mbR2QUUUVBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUyaGK4gkhuI0likUo8bqGV1IwQQeoI7U+uT+IeoeMNO8NyTeA9Ntr+92SFxM/zRgLwyL/G2ei96AI9B8OaP4Y8TanZ+H9Ot9PtpLS2maKBNqly84LfXAA/AVrnR9Na5luG060M82PMlMC7nwQRk4yeVU/8AAR6V5v8AB/VNY1TUtWk1a81K/AggDT6pa/Z5kbDEoqd0DtKM+2K6SfxDr8WuX0UWnSyWUMUjoxsZc5SSJRgjIfcryMMHJ29ByDu+hkb0miRLJ5mmzNpbsMSNZwwgy8kjcWRuhZiPdj61LNo+nXUCxXtlbXSq5k/fQI2XIwXxjG485PvWHba/rVxqGngabItncTzrcSPZyK0MazOsLYJB+dVXPHy53HAIq1r9/rdpNKdJt0liithJhoHcsxfacFTztXLbQCTjA60gNH+wtJFvLANLsvJmcPJH9nTa7A5BIxyQe9MfRo40CaXO+lJnLrZQwqJDgKCdyN0CgDGOBjsK5uXxB4ohis3TThcs6S7oorSYF2DuEyXChAVCkkkEZJAYEYs6RqWvXl5p7agpSE3EqSeXZzRh18lWUsHAKYbeM9DgDOaAOig02ztxH5drCHjIZXESg7gpXdwBg4JHHYkdKt1y/iTUNes9ScaLa+ZGlhJPvMEkoeRMlYxhgMtgD1547V1FMAooooEFFFFABRRRQBUudL0+8uY7i7sbaeeIYjllhVmQZzwSMjmoE8OaJFAsMWj2CRI/mKi2qBVfAG4DHXAAz7D0rO8WazqGlfZk0pA80yTMqC1ecyMi5VMKflBPBY8D261R07WPFF4GW4tIrZ3niXm0mPkBjJvB3bQ23ag3KSMknoRSGbw0VJo2i1W5k1aFsEQ3sMLKpHcBYxz9amGjaWEnQabaBbhdsw8hcSjAGG45GABz6CuJuNe8ST/6DZwyRzK0auq2czNErKzF2ct6hRtPOGPsRpjWfEyahZW72aeWZ2jlla1l/eqLlo8/KCE/dBXyxAJbI4BoA6BdC0hFgVNLslW33eSBboBFuOW28cZPJx1NNg0ZYCIzdSyWSjbHYtDCIY1H3VAWMHC4GOewrlNX13xXBp8H2azkknnCmRYtPl+RXkCYDAnDKuX5AHQ57V1F3Pf2/hpZbNC995cYAeMv8xIBJUEE4yT+FAE76Npcs08smm2jyXK7ZnaBSZRxwxxz90dfQelRt4e0V8b9IsGxH5QzbIcJyNvTp8x49z61y19r/i23vLiKKziKRM65FjcOSFYBWUqpVt4JbAPHAOMEhX1zxRdQX+bN7QJAzxqLKUyoQ6YxgFWLIXJVWJBwOoNAHUQ6Dp8Vy1w9vHPL57TxvNGrNCzYyEOMgZUH6/hiU6RYiYzwWsEF0EKJcxwp5kYOehIPdifTJPrXHQXOqvb6bKkuoSFhC8LxiSRCTcn7R5mOMCLG0NwBnbyOG+J7nVkS/njl1GNo4HlSSFZYoRAtm7hj2V/tAGQTuxgH5ScgHRa3ZRab8PNQsbbd5NtpckMe45O1YiBk/QVtw6FpNtMs1vpdlFKhyrpborKfYgVmeKv+RO1n/rwn/wDRbV5X4N8UfG288ZaZb+KNC8jSJJgLqX7Gq7Uwecg8UT+FfP8AQcd2e7UUUViaHP2f/JSdZ/7BNh/6OvK6CvB9I134jt8fdTt0s557EzSwlLu2+zwm1Rrg25aZYWKrkvtbB3kYye3rH2zxj/0AtD/8HU3/AMi1co2JUrnQUVz/ANs8Y/8AQC0P/wAHU3/yLR9s8Y/9ALQ//B1N/wDItTYdzoKK5/7Z4x/6AWh/+Dqb/wCRaPtnjH/oBaH/AODqb/5FosFzoKK5/wC2eMf+gFof/g6m/wDkWj7Z4x/6AWh/+Dqb/wCRaLBc6Ciuf+2eMf8AoBaH/wCDqb/5Fo+2eMf+gFof/g6m/wDkWiwXOgorn/tnjH/oBaH/AODqb/5Fo+2eMf8AoBaH/wCDqb/5FosFzoKK5/7Z4x/6AWh/+Dqb/wCRaPtnjH/oBaH/AODqb/5FosFzoK5q70jWpdblngltRateW8ihrq4DeUqkSfKG25yRhQNrfxAnFS/bPGP/AEAtD/8AB1N/8i1z+oax8VI7+VNP8K6DLbA/I7amxJ491Hf2H0qoycdhOKluaWl6TZa58O9L07VIfPtZrC38yPey5wqsOVIPUCuirmrG5u7T4Z2EumQNPe/2bAlvGFyDIyKqk+igkEnsAT2rMhl1aOzs7LW49UFtaXMsNxNbmV5Zl2hoG3xDcy4bazL/ABpzwSK2m/eaMorQ6lND0mJrkx6XZIbsFbgrboPOBOSG4+bJJzn1qVdOtooFjs4Y7QxxtHC8MSgwhsE7cggcgHGMEgZBrkZdT1OKwvbe1i1d7mSG3Nkbm1kyeBu3uiFVPHzd/bPFdB4ba9Onypq3nG/SdluGcERs3GDF28vbjAGcchiWDGoKLdpp5t5fOuLqW9mVSqTXEcQaNTgsoKIvBKqT/uj0oi0fTYLeKCDTrSOGFi8caQKFRiCpIAHBIYj6EjvV2imIZFFHBCkUKLHHGoVEQYCgcAAdhT6KKACiiigAooooAKKKKACiiigArOP/ACOmn/8AYPu//RlvWjWcf+R00/8A7B93/wCjLemgN2iiiuc2CiiigAooooAKKKKACiiigAooooAK861n/kv/AIf/AOwe/wD6DPXotedaz/yX/wAP/wDYPf8A9Bnrooby9H+RnU2Xqg0b/kv/AIg/7B6f+gwV6LXnWjf8l/8AEH/YPT/0GCvRaK+8fRfkKns/VnEW/wDySzxJ/wBdta/9Kriua/5tq/z/AM/ldLb/APJLPEn/AF21r/0quK5r/m2r/P8Az+VtR+Ff4kRPf5M9F8Jf8iXon/YPg/8ARa1r1keEv+RL0T/sHwf+i1rXrkn8TNo7IKKKKgoKKKKACiiigAooooAKKKKACiiigAooooAKKK5/xZ4d1HxFa28Wl+JL7QXics8lmqkygjGDu7d6AHj/AJHTUP8AsH2n/oy4rRrk/CehX/h/xBqtrqmvXmuyva20gubxVDopecbBt7Agn/gRoufDGpzawt6l+64naQr9rlA2+fC6Db04jWZcdPnx0JI3fQyOnYQXlsysI54JVKsDhlcHgg9iKgs7HTtNYwWFra2jSguY4Y1QuBgE4HXGRz7isHQbC68MRztqZdoJAkccdoZ7v5w0jF9oTKZDKMAYG0DPSqM3h3WNQvrjULW68rzYLhI5nuJo5XWSaF1Qxsn7nCRtHuGTyGxmkB23mJ5nl71343bc849cVHc2tve27QXkEdxC2N0cqBlODkZB461xk3hHW3S28m8CTJHsNw1/KXiHnmTA2oocbDs5xgcc96uu6b4oXSbnzC81zcCVbeGzvJ8RObeJI38xUBBDpIcEBP3mSwI5AO8tLK1sIPJsbaG2izny4Ywi59cCp65vxCZdctTpultdwXSS7i7xzW8bBc5HmeWQRnHTr2I4NUb3R9cv76a1jvZo4Vs4ncpNJErXWNp2OwbKbASQQw3EE5OaAOypGZUUs5CgdSTjFc9aS3Fvoo0a5af+0vJaITRwXDxBiDtPnFSOARk5656dKyY/CGrpZ6navdLNFcxARCe+mc7wwYc7flXg8/O3PXHFAHcUUlLTENWRGdkV1LJjcoPK/WlVldcqQw9Qa5jXPD+ranc3rW2oGGOSJ/s6i5kj2SeUAjHb6ON3f161my+EddFtaQ2eoeQtupVRFeugQ+cz7vuEvuQgEHG3BAJzmkM7gojOrlVLLnaxHIz1p1cfP4Z1dcpbXIdcR7ZJNRnVgoUeZFgA8OQx8wksN/TKrT4vDer/AOjPJe7GglV0RbyVlRftXmMucDd+5PljI9uBQB1YRFZmVVDN94gcn60rMq43EDJwMnqa4O78HeIXlDW+ryBGtwsiLfyofPzJ+9DFG6KUAGOcdtozfvNB1H7f9tnZZkgvRdeYLqcs8YfIUQqpUFUyABncR23GgDrqpw6RptveteQafaxXLElp0gUOSepLAZ5rnvEttqXijTPK8OzSWciLIPMuBcWjLIV/dsMp8wB5PB7YINR6v4X1m7Mr2epSo0s8zkLeyR7QQPKIO1sbOflAAy2c5AoA7GkDK2dpBwcHB6GuBk8I+JmieNdVYRlnZQuoSCTcRgOX8sj5eyhe+SxIFaA8LakmsXV1HdiOJr6O5hVbqUceajSblxjJQOmORz2ycAHQ2d5pYZbTT7iz3MHkWGB1yfmIZgo/2t2T6570l5eaTIlxbX9xZssOwzxTuhEeSCu4Hpk4xn2rlvD/AIe1BDaTyRxpCly1y/ms6TKwgkg8sDb93ncGz3OByDTdR8O6jbaRqhaKOUGwvoYFgd5pZXuWRgpyv8JXbuycjBO3BoA6PxWwXwbrJYgD7DMMk9yhAq1oHi/w94p87/hHdYs9RMBHmrbyhimehI64OOtc38VNHuta+H15DZTCNreSK7cMcB0icOy/kpI9wK8M+FfwO8dxeKF1K/abwzDa5HnFx5shIIwignpwctxwOvYn8K/rsOO7PrCivP8A/hXfiP8A6KRrn/fuP/Cj/hXfiP8A6KRrn/fuP/Cs7LuXd9jciuIbT4ga9cXUscEEOjWMkksjBVRRLeEsSeAAOc1oaZ4n0HWrlrfRtb03UJ1QyNFa3ccrBQQNxCknGSBn3FeX33w58QajrniHS4/HGpTTvo1uC1wqhbgSNdKschAJCAqeQM/O3tXH/C34W6/D4v11I/EX9kvpmbKefTyWeRyVfA3KBswM54OQOKrlTV7kczvsfSlFef8A/Cu/EX/RSNc/79x/4Uf8K78Rf9FI1z/v3H/hU2Xcu77HoFFef/8ACu/EX/RSNc/79x/4Uf8ACu/EX/RSNc/79x/4UWXcLvsegUV5/wD8K78Rf9FI1z/v3H/hR/wrvxF/0UjXP+/cf+FFl3C77HoFFef/APCu/EX/AEUjXP8Av3H/AIUf8K78Rf8ARSNc/wC/cf8AhRZdwu+x6BRXn/8AwrvxF/0UjXP+/cf+FH/Cu/EX/RSNc/79x/4UWXcLvsegUV5//wAK78Rf9FI1z/v3H/hR/wAK78Rf9FI1z/v3H/hRZdwu+x6BRXn/APwrvxF/0UjXP+/cf+FRTfDXxLJKWT4m69GMAbVjjx0x6fjSaQK50fhX/kTtG/68IP8A0WtWZ9Z0y1tIrq61G0ht5gDFNJOqpJkZ+VicHjnisextLrUPhnYWdhMsE1xpsEXnEkGNWRQzDH8QUkj3AzjrVOHwdqMccNomqG3t7Wed7ee1wkqLKoONpUrxIXwOm3aK6J/EzKOx0ba1pSXUVq+p2a3EwVooTOoeQN0IGcnPbFNGvaQ1k94uq2JtY32POLhNit6Fs4B56VzOn+F9Z0+REiWzWA2sFu8aXsgjGxNhzGYyXHfBcE9M96YvhXXBYsitbRskts0EYvXZkWPdkeeYt+PmG0MGxhufm4gZ07+ItEjWEyaxYIJxuhLXSDzBnGV555BHFXY7mCbb5U8b7wxXa4O7acNj6E4PpWUNNvZl0R7kxrLY3TTTAzmXKmGWMYYou45kU8gd/TnM0Dwnd6JrlvcrPCbMW1wJYFJys8kkbFk4+6wTkcfNzzuNAHW0UUUxBRRRQAUUUUAFFFFABRRRQAVnH/kdNP8A+wfd/wDoy3rRrOP/ACOmn/8AYPu//RlvTQG7RRRXObBRRRQAUUUUAFFFFABRRRQAUUUUAFedaz/yX/w//wBg9/8A0GevRa861n/kv/h//sHv/wCgz10UN5ej/IzqbL1QaN/yX/xB/wBg9P8A0GCvRa860b/kv/iD/sHp/wCgwV6LRX3j6L8hU9n6s4i3/wCSWeJP+u2tf+lVxXNf821f5/5/K6W3/wCSWeJP+u2tf+lVxXNf821f5/5/K2o/Cv8AEiJ7/JnovhL/AJEvRP8AsHwf+i1rXrI8Jf8AIl6J/wBg+D/0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABVe71CzsFVr+7gtlY4UzSBAT7ZqxWP4h8J6F4st4YPEemQahFAxeNZgSFJGCRQBTs721v/ABfqMtjcw3MYsLVS8MgcA+ZccZHfkVJL4k0mHU3sJL2ETRQyTzfOMRKhQHcc8H94tZvh7wzo3hXxLqdj4d0+HT7aS0tZmihBALl5wW+uFA/CppvCFpNdvOby8UfvGijUptgeSaOZnX5Mk+ZGrYYkckYxxW76GRZk8VaBEoMusWSAgkbp1HTr346Hj2Poav3t7FYWbXM+7y1Kg7Rk8kAfqayJ/CFpdxSLdXl5M8rs7yMybiWhkiPRcfdlbHHUDtxVm4tb3UFksr22t4rIkYmhumaQhWBX5TGAM4GeTj3pAObxLoi7t2rWY2Psb98vB59/9luf9k+hpYfEGlzaeb37ZFHEpCv5jgFGPRSOxORge4rOg8F21rdR3FtqWoRSxWws4mVo/wB3bgkiIfJ05HzH5vlHzdcongbTIbE2kEtxHF9oF0o/dsElwVZwGUjLBiCCCO4AbJJqBpW/iHS7zVk06yvIrmd4Gn/cuHARSg5IPfzFxWnWDo3hO00O5t5LS5uWitoJYYbdxGI4xIyO5AVAclowcZwMkAAYA3qYBRRRQIKKKKACqd1q2n2NzHb3l7bwTSjKJJIFLDOM4PvgfUgVcrn9c8KxeIL9jfXMq2MlusUtvEQPN2ybxkkEgZA+6QaBl3/hItINss6ajaujsUTbMvzsBnAyeuCD9CD0qG48WaJasqS6hBvLhGRZFYoT64PuBx/eX1FQ2vhCxtoWQTTOWEm59kSFt8axkkIijOEGDj/CoLHwbFb6jHeXN7cSm2nkktogUCIGK5B+XJJ2DOT9MUtQNca3pZlSNdRtS8kQmQCZfmQgsGHPI2gn6AntVabxVosSIV1GCUyYKJFIGZ8nAxzz3P0BPaqMHgXTLd4jHLPiOBYcMsbE4g8gPuKbg2zA4IHHTk5L/wAD2Go6hbXdxd3pNqyPFHvQqpWMx4GVJAIYkgEAnmjUDevL220+38+9nSCPIXc5xknoB6n2qn/wkuhmPzBq9kY8gbxOpXkZHOfTn6c1Ddaffa3bi31VI7KJHEgNndmUyEZ+VleIKV5zg55ArOj+HukxaLZ6Yk1wYrSN4keQRSMyMqqykMhXnYvIAPHXBIoA25Ne0qF5kl1G2VoCFkUyDKknGPrnj68VA/inRI5pI5dTto/LVGLNKApV13KQe4xznpjmqN14H0+61CW8a5uUkkl84Kgi2K/I3bSmHOCRl9xAPBHFOfwTpzxvH59ysb2P2HYmxVVPLMe4ALw23HtwMCjUCf8A4Suy/tCS08i5JiuFgkkCrtQs4jQn5s4ZyVHGflJIA5qVvElmdQ+yW8c1y24xLJDtKNMI2k8rJYfNsUnn5RxkgnFUofCatqNzdXVxInmXYn2QONsypIJYw+VyCr7vunkHknOBbbw+qal/aMdzPNOshuFgkdFjeby2iDEhMj5G28cYAOCeSagZ/ivxBp8fw1u9UmlMVtf2QSDcvzM067YxgdyXH0rB8D/tA+EvGepNp0gn0e7J/creldsw9mBIBHocfjzWl4q8LQ3Pwl/sm/kJbS7OKZZIuMyW6hh17Epj6GuK8Cfsy6boGqtf+KdSGrlOIbaKMxx4OQS+SS2QcY4/GlP4V/XYcd2ezf2/o/8A0FrH/wACU/xqW31bTrybyrS/tZ5MZ2RTKxx9Aa5r/hU3gT/oWLH/AL5P+NczD4X0Xwx8edCj0DTorFJ9KuGkWLOGIPBwT71Fkyrs1tJ8c+Hb34x6rpNtqO++ltILJIvIkGZreS7aZclcfKGBznBzwTR8O/8AkdPH3/YWX/0WKx7L4SeG3+Mer6jeLPfbYY9RNrdiOSF5LmS5VwyFOVGxSo6g8kmjwH4R8N3ni7xtDd+HtKnittUWOBJbKNliXYDtUFflHsKp2toSr9T1iiuf/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/iajQvU6Ciuf/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/iaNA1Ogorn/APhAfB3/AEKeh/8Agth/+Jo/4QHwd/0Keh/+C2H/AOJo0DU6Ciuf/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/iaNA1Ogorn/APhAfB3/AEKeh/8Agth/+Jo/4QHwd/0Keh/+C2H/AOJo0DU6Ciuf/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/iaNA1OgqhNrukW0zQ3GqWUUqHDJJcIrKfcE1nf8ID4O/wChT0P/AMFsP/xNZ118JPAN5cvPceFdOaR8ZKxbRwMDAGAOB2o0GS6RqEOlfDvTr+63eTb6ZDI+3rgRj14/E4HqRTpfFlpBYLcz2l4nyySPHtRikSAM8uQxVkAZeVLcnABOQF0K2+2eAtKgE81uX0+DEsDbXQ7FIIzkfgQQehBHFVv+EHsBZywC7u0M5l86SMRIZFlVVdNoQKoIRD8oByM5ySTvP4mYx2NTStcttXklW2SVNiJKpkUASxOWCSLgn5TsbGcHjpyKS91+w0/VIbG7kMcksTy7yPkQKC3zHsSEkI9RG3pVa00STQ1d9I/0yRkjgWO8uPLWGFC5RFKxknG8jkE46nioLvwfYazJJeaxE322Zo2YxzbhEqf8s0JUfIfnzkZPmP6jEjLdt4jin8nzbG+tVuGjELTxACQPnaQQTj7vKnDDIyBmpJNfso9Y/soeZJellAhRcnaQCX68KoIyT3IHJIBqf8IrmCON9b1RmgMZgdmizFszjA8vac55LAngc1J/wi1odQXUWnnbUA8Tfa/kEh2ArtOFA2sCwIxjnIwQCDUDbooopiCiiuYsdU1GX7X/AGZcpru3V5LWbdELf7AnGRzjzRH7ctu4IxTSuJux09FY3h69+2f2p/xNv7S8jUZof+Pbyfs2Mfuf9vbn7/fNZ+t+N4NDm1iKazkkfTrRbiIK4H2kkgFR/dwWjyT/AH89qGrOw1qdTRXMS+LnGqwWFtp4ke8lmhs2efaJGhYCXf8AKdgHzYxuzt6DIrd02/j1PSbTUIlaOO6gSdVfqoZQ2D780hlqiuRj+IVg+ivqxgc2kdyIJDHIrMA6hoXx3D7kH+yWweFYjcsNVa71K6sZrfyZrWGGSTD7hmQNwDgdNvXvSA0qzj/yOmn/APYPu/8A0Zb1yetfFLSNM8V2enR3kRtY5J4tTd7eUtAyDCBcDnLZBwG/DrW1d6ksupWGp6aXmSTRrueApEWZwTbsuEypJPHy5BPTitfZyW/UjmR19FcvdeLtE8N3t1FreqeXJNNvRDvm2ARxjGFX5PXbk/e3fxYEP/C0/B3/AEGP/JWb/wCIrH2NR7Rb+Rr7SPVnXUVyP/C0/B3/AEGP/JWb/wCIo/4Wn4O/6DH/AJKzf/EUexq/yv7g9pDuddRXI/8AC0/B3/QY/wDJWb/4ij/hafg7/oMf+Ss3/wARR7Gr/K/uD2kO511Fcj/wtPwd/wBBj/yVm/8AiKP+Fp+Dv+gx/wCSs3/xFHsav8r+4PaQ7nXUVyP/AAtPwd/0GP8AyVm/+Io/4Wn4O/6DH/krN/8AEUexq/yv7g9pDuddRXI/8LT8Hf8AQY/8lZv/AIij/hafg7/oMf8AkrN/8RR7Gr/K/uD2kO511edaz/yX/wAP/wDYPf8A9Bnr0WvOtZ/5L/4f/wCwe/8A6DPV0N5ej/IVTZeqDRv+S/8AiD/sHp/6DBXotedaN/yX/wAQf9g9P/QYK9For7x9F+Qqez9WcRb/APJLPEn/AF21r/0quK5r/m2r/P8Az+V0tv8A8ks8Sf8AXbWv/Sq4rmv+bav8/wDP5W1H4V/iRE9/kz0Xwl/yJeif9g+D/wBFrWvWR4S/5EvRP+wfB/6LWteuSfxM2jsgoooqCgooooAKKKKACiiigAooooAKKKKACiiigAooooAwtVivLLWRqdpaNeQyW4huY4iPMXaxZGUHG4fO+RnPTGaYdftQcG21TI6/8Sq5P8o66CitFNWs0Q466HP/APCQWn/Ptqn/AIKbr/43R/wkFp/z7ap/4Kbr/wCN10FFPnj2Fyvuc/8A8JBaf8+2qf8Agpuv/jdH/CQWn/Ptqn/gpuv/AI3XQVl+JpJIvC+oPA7JIsDFWRipB9iOR9acZJu1gcWlcp/8JBaf8+2qf+Cm6/8AjdH/AAkFp/z7ap/4Kbr/AON1A8Wq6WWkjkjgW6lgt443uJLsISxDPl9pBwQMDj5c1Cnia+8h3D200n2eSSSJUObNldVHmfN0wzEjgnYccdNLJ7fmT6l3/hILT/n21T/wU3X/AMbo/wCEgtP+fbVP/BTdf/G6z77xRd2r+XbXNrdKqO6XCoqpOwI/dglxkjOCU3HJHGQRSf8ACUXu26UzWvmRuvIC7VUuVI3F+GwAAJAnOevQPldtvx/4Armj/wAJBaf8+2qf+Cm6/wDjdH/CQWn/AD7ap/4Kbr/43VODxPczvARLArM1uq27RbZLkSMA7r8xwBzjG4fKTkg5F1Lu7u/Cl7dXV35DOJQkkEJzAoJXPBycYzkYqWrbr+vuHuJ/wkFp/wA+2qf+Cm6/+N0f8JBaf8+2qf8Agpuv/jdZ+n6r9ht72eCWKW3tTDJO8N21zD5bFg7KW5VgPmZckYAPc086/qX26C2naKJ7mIFYkQNIhdWIBBYNxwMqGHDZx2fLrsIu/wDCQWn/AD7ap/4Kbr/43R/wkFp/z7ap/wCCm6/+N1j6D4pv7qK3jkkimPllWzt3ELDuEnDljkgfwgYPXPW7a63qplhM8ts6MbQsqwFSRPwRncemMim42drfj/wATuW/+EgtP+fbVP8AwU3X/wAbo/4SC0/59tU/8FN1/wDG6z9eN82qas1sksscFrCcpeyxNDnfl1ROHIxnGQTjAqS08SXcup/ZkeGVFLou7bllWIssvysWIY4P3cYYYOeq5Va6/MOti5/wkFp/z7ap/wCCm6/+N0f8JBaf8+2qf+Cm6/8AjdZSeLbw20YaSHLS7ZLgLH5afu9wAYy7Tk56kHA5Gea19Fv7q71aU3cqr5ljbTrbD+AsG3Ed8ZGPyolHlV2vx/4A1qN/4SC0/wCfbVP/AAU3X/xuj/hILT/n21T/AMFN1/8AG66CisuePYrlfc5//hILT/n21T/wU3X/AMbo/wCEgtP+fbVP/BTdf/G66Cijnj2Dlfc5e+nuNetX07T7C6ENyvlz3N1C0Cxxk4bCuAzNtzgAY9SK6iiiplLm0KUbBXzPrPxY1S3+PEdxd2lqYNJvptLAhhdna3M21jjdzJtHGOM9q+mK8v1XQNHj/aA0Fo9JsUaWxuLuQrbIC8wcESnjlwed3XNEGtbikn0K9t8WdBTxvqd8bLWfKm06zhVRp0m4MklySSOw/eDB74PpWP4M+Jmi6Z4n8XXVxaaqyX+orNEIrF2ZV2AYYD7p9jXqFn/yUnWf+wTYf+jryuf+Hf8AyOnj7/sLL/6LFPSzFrdB/wALl8O/8+Ouf+CySj/hcvh3/nx1z/wWSV6BRU3XYvU8/wD+Fy+Hf+fHXP8AwWSUf8Ll8O/8+Ouf+CySvQKKLrsGp5//AMLl8O/8+Ouf+CySj/hcvh3/AJ8dc/8ABZJXoFFF12DU8/8A+Fy+Hf8Anx1z/wAFklH/AAuXw7/z465/4LJK9Aoouuwann//AAuXw7/z465/4LJKP+Fy+Hf+fHXP/BZJXoFFF12DU8//AOFy+Hf+fHXP/BZJR/wuXw7/AM+Ouf8Agskr0Cii67Bqef8A/C5fDv8Az465/wCCySopvjd4aglKPp+vEgA/LpUhHIz/AFr0Wik7dAVzkNNu5rH4b6dcWiRyXCabB5SSOFVnKKFGSQOSQMZGTxkZzWdL4vv4tPnIW2a6s47mecSQSRfLCkbmMoxyjsJVwdzrgbuc4G14cghuvA2kwXMSTQyadCrxyKGVwYxkEHgirQ0HSBapajSrIW8cnmpF9nTar/3gMYB561vP4mZR2KPhzXLnV5XFykKq9pBeReWCCiSmQBGyTlh5fJGOTjAxzT13xkNI8Qpp6ojRiHM0jBvkkcMYhkcdU2kHnMseO9bT6PBGkn9mN/Zck0nmSy2cMQaU8/e3IQeTnOM+/WnrpdqbR4LqKO7EzK8zTxITM4xhmAUAkbVwcfwj0qRnH2/jPWZraQeTEZt1qqsbGRGUy7iR5Rk3OAFGGDAHJHVTWjqfiLVNOt7eVhb+Wlu095K9q42ANxujVy8SkBvnw4GDkDHO9c6Npd6gW802zuFCqgEsCsNqnKjkdAeQO1Mbw/ozx28b6RYsltnyFNsmIsnJ2jHGSM8d6AMq11XWdR1i+trd4IIYJ3hjeTT3kX5QOS4lUHr0wKx5vHOp6bodrqOowWksNxpP255YkaNYJGUGNWBZsqW+UtkcsvAGSOwTRdLj1I6hHptml6xLG5WBRISRgndjPTintpdg9qbZ7G2aAwfZzEYVKmLGPLxjG3H8PSgC0pyoPqKxJPD0l/u/trUpbzyr1ruy8uNYfs3Tyxx98p82C3B3fMDgY2+lLVJtbCtcp6dbXtt9q+33/wBt825eSD9ysfkxHG2Pj72OfmPJzVW/8M6Rqlw899ZiWRwwZvMYZDRmMjg/3SR9cHqARrUUnqBjzeFtInu2uXt5BMWLq6XEiGNiQWKYYbCxUZ24z3zk059InNv/AGdHNax6R5It/sqwOJBFt2lRIJBjjoQMj9a1qKBmS/hfRJLz7S2nQl/K8kpgiMrhhzH90nEjjOM4Yjoas2WlWenSPJaxsrvFHEzvKzlljBC5LE5Iyeep75q7RQIzb3Q7a/13S9WmeVZ9M83yVUja3mKFbcMZPA4wRVXVLIaj4ht7M7MT6VexneCVwz245AIOOexB9xW5Wcf+R00//sH3f/oy3qlJ/cKyZKdEtNRuLk61pdtdCOXFu9zFHL8mxCdvy5Ubt3BycgnoQAv/AAiXhz/oAaX/AOAUf+Fa9FY88u5ryoyP+ES8Of8AQA0v/wAAo/8ACj/hEvDn/QA0v/wCj/wrXoo55dx8q7GR/wAIl4c/6AGl/wDgFH/hR/wiXhz/AKAGl/8AgFH/AIVr0Uc8u4cq7GR/wiXhz/oAaX/4BR/4Uf8ACJeHP+gBpf8A4BR/4Vr0Uc8u4cq7GR/wiXhz/oAaX/4BR/4Uf8Il4c/6AGl/+AUf+Fa9FHPLuHKuxkf8Il4c/wCgBpf/AIBR/wCFcH8XtD0nTPCNrNpul2VpK18iF4LdI2K+XIcZA6cD8q9Trzr42f8AIl2n/YQT/wBFyVvh5SdWN2ZVYrkZ6LXnWs/8l/8AD/8A2D3/APQZ69FrzrWf+S/+H/8AsHv/AOgz1NDeXo/yKqbL1QaN/wAl/wDEH/YPT/0GCvRa860b/kv/AIg/7B6f+gwV6LRX3j6L8hU9n6s4i3/5JZ4k/wCu2tf+lVxXNf8ANtX+f+fyult/+SWeJP8ArtrX/pVcVzX/ADbV/n/n8raj8K/xIie/yZ6L4S/5EvRP+wfB/wCi1rXrI8Jf8iXon/YPg/8ARa1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEN3aQ3tu0FypaJj8yhiu72ODyPUdD3qaiigAooooAKKKKACiiigAooooAKKKKACiiigArz/WP+S++HP+wTdf+hCvQK8v1XX9Hk/aA0FY9WsXaKxuLSQLcoSkxcARHnhyeNvXNVEmRy+ka78R2+Pup26Wc89iZpYSl3bfZ4Tao1wbctMsLFVyX2tg7yMZPboPAdz4kXxd42NppOlSytqimdZdUkRY22DhSLdtw9yF+ldxZ/8AJSdZ/wCwTYf+jryuf+Hf/I6ePv8AsLL/AOixVN3WxKVjoPtnjH/oBaH/AODqb/5Fo+2eMf8AoBaH/wCDqb/5FroKKi5Zz/2zxj/0AtD/APB1N/8AItH2zxj/ANALQ/8AwdTf/ItdBRRcDn/tnjH/AKAWh/8Ag6m/+RaPtnjH/oBaH/4Opv8A5FroKKLgc/8AbPGP/QC0P/wdTf8AyLR9s8Y/9ALQ/wDwdTf/ACLXQUUXA5/7Z4x/6AWh/wDg6m/+RaPtnjH/AKAWh/8Ag6m/+Ra6Cii4HP8A2zxj/wBALQ//AAdTf/ItH2zxj/0AtD/8HU3/AMi10FFFwOf+2eMf+gFof/g6m/8AkWuf1DWPipHfypp/hXQZbYH5HbU2JPHuo7+w+legUUDOISO7m+FNlFp0s8NzJp1ukcluD5iZVASvuBk1lQXfiC8v5rnV4tSt7CQWqTQ28cgaMKJ1kKbBu5lCEleTGVPSun8OTxW3gfSJrmVIYk0+AvJIwVVHlrySelaFxqFnaCU3V3BAIVV5TJKF2KxIUnJ4BIIB7kGt5/EzGOxyejy642qaV/aYvxcFYhOCjCHyfshLlsDYH+0df4vu9queKrvXI9Qtm0S1uJYbBPtlyI+PPG7HlLx85KCX5R0Yxn0rduX02+b+zrtrW4aVBJ9llKuXQHhth6jI606CGw0uOO3to7ezSVyscUarGHfBJAAxk4BP0BqRnLzS3n26+Mv9s/2h50ot1t0k+z+T5ZKZyPL9Cf49/HTiq91qWtXklrJYxaiNPitI/wC0QbaaGdsMNwiDKCWwckjkgEL8xBHWjWNMN89kNRtDdICXg89fMXAycrnI45qEeJdCa3a4XWtPMKsEaQXSbQxyQCc4ycHj2oA0hyKWqUmsabDfR2U2o2kd1JjZA06h3z0wucnNMt9e0e7mMVpqtjPIpClIrlGIJOAMA+vFMRoUU1JEkUmN1cAlSVOcEHBH4EYp1ABRRRQAUUUUAFFFFABWcf8AkdNP/wCwfd/+jLetGs4/8jpp/wD2D7v/ANGW9NAbtFFFc5sFFFFABRRRQAUUUUAFFFFABXnXxs/5Eu0/7CCf+i5K9Frzr42f8iXaf9hBP/RcldGG/jRMqvwM9FrzrWf+S/8Ah/8A7B7/APoM9ei151rP/Jf/AA//ANg9/wD0GeihvL0f5DqbL1QaN/yX/wAQf9g9P/QYK9FrzrRv+S/+IP8AsHp/6DBXotFfePovyFT2fqziLf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K6W3/AOSWeJP+u2tf+lVxXNf821f5/wCfytqPwr/EiJ7/ACZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFfM+s/CzXW+PEaJqVravqd9Nq0E8LsXgiE2/PKY8wA8DkZHWvpivP9Y/5L74c/7BN1/6EKuDauRJJmPbeBNebxvqdsPH+srLHp1nI1wEj3SK0lyAh46LsJH++ax/BngzWr3xP4ugt/G2q2b2uorHLNEibrltgO9s9+3FdhpPjnw7e/GPVdJttR330tpBZJF5EgzNbyXbTLkrj5QwOc4OeCaPh3/yOnj7/sLL/wCixVXaTFZB/wAK78Rf9FI1z/v3H/hR/wAK78Rf9FI1z/v3H/hXoFFRzMvlR5//AMK78Rf9FI1z/v3H/hR/wrvxF/0UjXP+/cf+FegUUczDlR5//wAK78Rf9FI1z/v3H/hR/wAK78Rf9FI1z/v3H/hXoFFHMw5Uef8A/Cu/EX/RSNc/79x/4Uf8K78Rf9FI1z/v3H/hXoFFHMw5Uef/APCu/EX/AEUjXP8Av3H/AIUf8K78Rf8ARSNc/wC/cf8AhXoFFHMw5Uef/wDCu/EX/RSNc/79x/4Uf8K78Rf9FI1z/v3H/hXoFFHMw5Uef/8ACu/EX/RSNc/79x/4VFN8NfEskpZPibr0YwBtWOPHTHp+Nei1Qm13SLaZobjVLKKVDhkkuEVlPuCaTbYJWOattL/tr4Yafp2I2Fxp9urCT7pXahIP4A1n2HhDWLPUDqU09reXYNvlZJWVZhCs0Y3HaSPkkR+h+cN2wa2NI1CHSvh3p1/dbvJt9Mhkfb1wIx68ficD1Ip0viy0gsFuZ7S8T5ZJHj2oxSJAGeXIYqyAMvKluTgAnIG8/iZlHYyrDw9d6C2nSXDRTWtk0MskkKSSSlltDbbFjVSSuTvznjLcd6m1vSL7xPPFe6bdfZFso99olxbuha4Dh8urqCqjy0GRkkPIPr0FhqlvqUt7HbCUGyuDbS+ZGUy4RW4z1GHHPQ9uOahvdfsNP1SGxu5DHJLE8u8j5ECgt8x7EhJCPURt6VIzBuvCF9NfPdC7Vw11PN9lkkPlIJImQOMLneNx4OQQzd8ERJ4c18adaxSCBp7UARyf2rJuU7NpKt5OAO2xlYHOeNvO9beI4p/J82xvrVbhoxC08QAkD52kEE4+7ypwwyMgZqSTX7KPWP7KHmSXpZQIUXJ2kAl+vCqCMk9yBySATQDH0/QdZsNYhn328kHkW0c3k3JgXKJtYiIREEeg3D04qbUvCrap9viuWjMF3qcV2NrkMqLBGmQQOHDJkEdODnNdNRQBkeGtOvdK0UW2qzxXF19onleaJcK4eV3Bx2OGGR0ByBkc1r0UUxBRRRQAUUUUAFFFFABWcf8AkdNP/wCwfd/+jLetGs4/8jpp/wD2D7v/ANGW9NAbtFFFc5sFFFFABRRRQAUUUUAFFFFABXnXxs/5Eu0/7CCf+i5K9Frzr42f8iXaf9hBP/RcldGG/jRMqvwM9FrzrWf+S/8Ah/8A7B7/APoM9ei151rP/Jf/AA//ANg9/wD0GeihvL0f5DqbL1QaN/yX/wAQf9g9P/QYK9FrzrRv+S/+IP8AsHp/6DBXotFfePovyFT2fqziLf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K6W3/AOSWeJP+u2tf+lVxXNf821f5/wCfytqPwr/EiJ7/ACZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/yX3w5/2Cbr/wBCFegV8z6z8WNUt/jxHcXdpamDSb6bSwIYXZ2tzNtY43cybRxjjPargm7kSaR6BZfCTw2/xj1fUbxZ77bDHqJtbsRyQvJcyXKuGQpyo2KVHUHkk0eA/CPhu88XeNobvw9pU8VtqixwJLZRssS7Adqgr8o9hRbfFnQU8b6nfGy1nyptOs4VUadJuDJJckkjsP3gwe+D6Vj+DPiZoumeJ/F11cWmqsl/qKzRCKxdmVdgGGA+6fY1XvWJ909Q/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/ia5/wD4XL4d/wCfHXP/AAWSUf8AC5fDv/Pjrn/gskqbSLvE6D/hAfB3/Qp6H/4LYf8A4mj/AIQHwd/0Keh/+C2H/wCJrn/+Fy+Hf+fHXP8AwWSUf8Ll8O/8+Ouf+CySi0gvE6D/AIQHwd/0Keh/+C2H/wCJo/4QHwd/0Keh/wDgth/+Jrn/APhcvh3/AJ8dc/8ABZJR/wALl8O/8+Ouf+CySi0gvE6D/hAfB3/Qp6H/AOC2H/4mj/hAfB3/AEKeh/8Agth/+Jrn/wDhcvh3/nx1z/wWSUf8Ll8O/wDPjrn/AILJKLSC8ToP+EB8Hf8AQp6H/wCC2H/4mj/hAfB3/Qp6H/4LYf8A4muf/wCFy+Hf+fHXP/BZJR/wuXw7/wA+Ouf+CySi0gvE6D/hAfB3/Qp6H/4LYf8A4mj/AIQHwd/0Keh/+C2H/wCJrn/+Fy+Hf+fHXP8AwWSUf8Ll8O/8+Ouf+CySi0gvE6D/AIQHwd/0Keh/+C2H/wCJrOuvhJ4BvLl57jwrpzSPjJWLaOBgYAwBwO1UP+Fy+Hf+fHXP/BZJUU3xu8NQSlH0/XiQAfl0qQjkZ/rSafUat0NzQrb7Z4C0qATzW5fT4MSwNtdDsUgjOR+BBB6EEcVW/wCEHsBZywC7u0M5l86SMRIZFlVVdNoQKoIRD8oByM5ySS/Tbuax+G+nXFokclwmmweUkjhVZyihRkkDkkDGRk8ZGc1nS+L7+LT5yFtmurOO5nnEkEkXywpG5jKMco7CVcHc64G7nOBtP4mZR2Oja0nsXu59LijuJry4E0qXE5jVcRrH8pVGPSNeCO557Vm3fg+w1mSS81iJvtszRsxjm3CJU/5ZoSo+Q/PnIyfMf1GNDSdQub271WG7hji+xXvkR+W5benlRuGOQME7+nb1PWsjXfGQ0jxCmnqiNGIczSMG+SRwxiGRx1TaQecyx471Iy3/AMIrmCON9b1RmgMZgdmizFszjA8vac55LAngc1J/wi1odQXUWnnbUA8Tfa/kEh2ArtOFA2sCwIxjnIwQCOdt/GeszW0g8mIzbrVVY2MiMpl3EjyjJucAKMMGAOSOqmtHU/EWqadb28rC38tLdp7yV7VxsAbjdGrl4lIDfPhwMHIGOTQDrKK5m11XWdR1i+trd4IIYJ3hjeTT3kX5QOS4lUHr0wKx5vHOp6bodrqOowWksNxpP255YkaNYJGUGNWBZsqW+UtkcsvAGSC4HfUUinKg+opaYgooooAKKKKACiiigArOP/I6af8A9g+7/wDRlvWjWcf+R00//sH3f/oy3poDdooornNgooooAKKKKACiiigAooooAK86+Nn/ACJdp/2EE/8ARclei1518bP+RLtP+wgn/ouSujDfxomVX4Gei151rP8AyX/w/wD9g9//AEGevRa861n/AJL/AOH/APsHv/6DPRQ3l6P8h1Nl6oNG/wCS/wDiD/sHp/6DBXotedaN/wAl/wDEH/YPT/0GCvRaK+8fRfkKns/VnEW//JLPEn/XbWv/AEquK5r/AJtq/wA/8/ldLb/8ks8Sf9dta/8ASq4rmv8Am2r/AD/z+VtR+Ff4kRPf5M9F8Jf8iXon/YPg/wDRa1r1keEv+RL0T/sHwf8Aota165J/EzaOyCiiioKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8v1XQNHj/AGgNBaPSbFGlsbi7kK2yAvMHBEp45cHnd1zXqFef6x/yX3w5/wBgm6/9CFVEmR0Fn/yUnWf+wTYf+jryuf8Ah3/yOnj7/sLL/wCixXQWf/JSdZ/7BNh/6OvK5/4d/wDI6ePv+wsv/osU+jDqj0CiiioKCiiigAooooAKKKKACiiigAooooAKKKKAOZ8OQQ3XgbSYLmJJoZNOhV45FDK4MYyCDwRVoaDpAtUtRpVkLeOTzUi+zptV/wC8BjAPPWoPCrKfCmmxBgXt7dLeUf3ZEARlPuCCK166Z/EzCOxUubHzUf7JcSWEkkgkklt0j3SHaF+berA8BRnGflAzimrpdqbR4LqKO7EzK8zTxITM4xhmAUAkbVwcfwj0q7RUjKNzo2l3qBbzTbO4UKqASwKw2qcqOR0B5A7UxvD+jPHbxvpFiyW2fIU2yYiycnaMcZIzx3rRooAopoulx6kdQj02zS9YljcrAokJIwTuxnpxT20uwe1Ns9jbNAYPs5iMKlTFjHl4xjbj+HpVuigBOlLRRQAUUUUAFFFFABRRRQAVnH/kdNP/AOwfd/8Aoy3rRrNRll8bW4jYMbbT5vNA/h8ySLZn6+W/5U11A3qKKK5zYKKKKACiiigAooooAKKKKACvOvjZ/wAiXaf9hBP/AEXJXotedfGz/kS7T/sIJ/6Lkrow38aJlV+Bnotedaz/AMl/8P8A/YPf/wBBnr0WvOtZ/wCS/wDh/wD7B7/+gz0UN5ej/IdTZeqDRv8Akv8A4g/7B6f+gwV6LXnWjf8AJf8AxB/2D0/9Bgr0WivvH0X5Cp7P1ZxFv/ySzxJ/121r/wBKriua/wCbav8AP/P5XS2//JLPEn/XbWv/AEquK5r/AJtq/wA/8/lbUfhX+JET3+TPRfCX/Il6J/2D4P8A0Wta9ZHhL/kS9E/7B8H/AKLWteuSfxM2jsgoooqCgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP8AWP8Akvvhz/sE3X/oQr0CvP8AWP8Akvvhz/sE3X/oQqoiZ0Fn/wAlJ1n/ALBNh/6OvK5/4d/8jp4+/wCwsv8A6LFdBZ/8lJ1n/sE2H/o68rn/AId/8jp4+/7Cy/8AosU+jF1R6BRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAGZceHdOubuW5ZbiKWbHmG2u5YQ5HchGAJ4xnrjiov+EW07/nrqf8A4Nrr/wCOVsUVfPPuTyx7GP8A8Itp3/PXU/8AwbXX/wAco/4RbTv+eup/+Da6/wDjlbFFHtJ9w5Y9jmH03Rk1tNLaTVvOePeH/tS52ZOSEz5v3iFY49FPtVO4Gh2yXW8a0ZbNJZLiFdUuN0aIu7cf3uMMMbeed3s2NiXw0ktxJdm7lF610tykoZtibcAL5e7afkG0nqck8VBeeFnuobsjUGS6vopYbqUxZWRHUhVC7uNnGOf7394mtlNdZMhxfYLvRdJsprWOaXVP9JlMSsNVucKRG7kn950wh/Sqy2/hqS4t4YNRvpmuHKJ5er3LAHaW5/edCBwa3dT03+0WtD5vl/Z5Xk+7nduiePHXj/WZ/CsyTwp5lzBL9swI7WK1ZfK+8qpKpIO7gnzeOuNvfPExnprJjceyIfsPhs2z3A1W78lCAz/2zc4BPT/lp37etL9g8N4lI1S7PlcP/wATq545x/z09ePrx1qaz8MPbqnnXoldXgIbY5ysRJA+Z26lj0wB6U4eHrpI7eNNQjCWcm+2Bts4+b+M7stwSONvqc8U+ZfzMXL5Fd7Dw3GkTPql2qzDdGTrVzhhnGR+86Z4pY9O8OymYR6ndt5Kl5P+J1c/IBwSf3nQd/SpX8LmSzuonvB5l1a3MDuIuA0zliwGegJ6Z/GifwqJ7SOE3jL5cE8QZUxzJKkgbg9jHjHfPUUcy/mYcr7EH2Hw3sjY6pdgSMVXOs3IyRgH/lp7j8x61Lp+jaPqdr9otJ9UaPeyc6rdDlWIP/LT2pbbw3c2lxNcQaggmuQVnZoGkyuFA273JyAvViw6cYGK1tMsm0+0aBpRIvmyOhCbcBnLYPJyRnGePpSlOy0kxqOuqKX/AAi2nf8APXU//Btdf/HKP+EW07/nrqf/AINrr/45WxRWftJ9yuWPYxx4X09WBEupZBzzqtyf/alXdP0u00uJ47KNl8xt8jvI0ju3qzMSx445PSrdFJzk9GxqKWyCiiipGFFFFABRRRQAUUUUAFFFFABXnXxs/wCRLtP+wgn/AKLkr0WvOvjZ/wAiXaf9hBP/AEXJXRhv40TKr8DPRa861n/kv/h//sHv/wCgz16LXnWs/wDJf/D/AP2D3/8AQZ6KG8vR/kOpsvVBo3/Jf/EH/YPT/wBBgr0WvOtG/wCS/wDiD/sHp/6DBXotFfePovyFT2fqziLf/klniT/rtrX/AKVXFc1/zbV/n/n8rpbf/klniT/rtrX/AKVXFc1/zbV/n/n8raj8K/xIie/yZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/ANFrWvXJP4mbR2QUUUVBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8l98Of9gm6/9CFegV5/rH/JffDn/YJuv/QhVREzoLP/AJKTrP8A2CbD/wBHXlc/8O/+R08ff9hZf/RYroLP/kpOs/8AYJsP/R15XP8Aw7/5HTx9/wBhZf8A0WKfRi6o6n/hLfDn/Qf0v/wNj/xo/wCEt8Of9B/S/wDwNj/xrynwHoHhS48C32t+LLbclteGJpvMlG1SseBtQ8/M/p3rR/4s5/n7ZXXKhBSaXM7dkYqpJq+h6L/wlvhz/oP6X/4Gx/40f8Jb4c/6D+l/+Bsf+Nedf8Wc/wA/bKP+LOf5+2UvYR7S+4ftH3X3nov/AAlvhz/oP6X/AOBsf+NH/CW+HP8AoP6X/wCBsf8AjXnX/FnP8/bKP+LOf5+2Uewj2l9we0fdfeei/wDCW+HP+g/pf/gbH/jR/wAJb4c/6D+l/wDgbH/jXnX/ABZz/P2yj/izn+ftlHsI9pfcHtH3X3nov/CW+HP+g/pf/gbH/jR/wlvhz/oP6X/4Gx/4151/xZz/AD9so/4s5/n7ZR7CPaX3B7R91956L/wlvhz/AKD+l/8AgbH/AI0f8Jb4c/6D+l/+Bsf+Nedf8Wc/z9so/wCLOf5+2Uewj2l9we0fdfeei/8ACW+HP+g/pf8A4Gx/40f8Jb4c/wCg/pf/AIGx/wCNedf8Wc/z9so/4s5/n7ZR7CPaX3B7R91956L/AMJb4c/6D+l/+Bsf+NH/AAlvhz/oP6X/AOBsf+Nedf8AFnP8/bKP+LOf5+2Uewj2l9we0fdfeei/8Jb4c/6D+l/+Bsf+NH/CW+HP+g/pf/gbH/jXnX/FnP8AP2yj/izn+ftlHsI9pfcHtH3X3nov/CW+HP8AoP6X/wCBsf8AjR/wlvhz/oP6X/4Gx/4151/xZz/P2yj/AIs5/n7ZR7CPaX3B7R91956L/wAJb4c/6D+l/wDgbH/jR/wlvhz/AKD+l/8AgbH/AI151/xZz/P2yj/izn+ftlHsI9pfcHtH3X3nov8Awlvhz/oP6X/4Gx/40f8ACW+HP+g/pf8A4Gx/4151/wAWc/z9so/4s5/n7ZR7CPaX3B7R91956L/wlvhz/oP6X/4Gx/40f8Jb4c/6D+l/+Bsf+Nedf8Wc/wA/bKP+LOf5+2Uewj2l9we0fdfeei/8Jb4c/wCg/pf/AIGx/wCNH/CW+HP+g/pf/gbH/jXnX/FnP8/bKP8Aizn+ftlHsI9pfcHtH3X3nov/AAlvhz/oP6X/AOBsf+NH/CW+HP8AoP6X/wCBsf8AjXnX/FnP8/bKP+LOf5+2Uewj2l9we0fdfeei/wDCW+HP+g/pf/gbH/jR/wAJb4c/6D+l/wDgbH/jXnX/ABZz/P2yj/izn+ftlHsI9pfcHtH3X3nov/CW+HP+g/pf/gbH/jR/wlvhz/oP6X/4Gx/4151/xZz/AD9so/4s5/n7ZR7CPaX3B7R91956L/wlvhz/AKD+l/8AgbH/AI0f8Jb4c/6D+l/+Bsf+Nedf8Wc/z9so/wCLOf5+2Uewj2l9we0fdfeei/8ACW+HP+g/pf8A4Gx/40f8Jb4c/wCg/pf/AIGx/wCNedf8Wc/z9so/4s5/n7ZR7CPaX3B7R91956L/AMJb4c/6D+l/+Bsf+NH/AAlvhz/oP6X/AOBsf+Nedf8AFnP8/bKP+LOf5+2Uewj2l9we0fdfeei/8Jb4c/6D+l/+Bsf+NH/CW+HP+g/pf/gbH/jXnX/FnP8AP2yj/izn+ftlHsI9pfcHtH3X3nov/CW+HP8AoP6X/wCBsf8AjXB/F7XNJ1Pwjaw6bqlldyrfI5SC4SRgvlyDOAenI/Oq3/FnP8/bKP8Aizn+ftlXTpxhNSUZaeRMpOUbXX3nrledaz/yX/w//wBg9/8A0Get20+JHhS+vYLS11XzJ7iRYo0+zSjczHAGSuByawtZ/wCS/wDh/wD7B7/+gz1jShKLlzK2j/Iuck0rPqg0b/kv/iD/ALB6f+gwV6LXnWjf8l/8Qf8AYPT/ANBgr0Wpr7x9F+Q6ez9WcRb/APJLPEn/AF21r/0quK5r/m2r/P8Az+V0tv8A8ks8Sf8AXbWv/Sq4rmv+bav8/wDP5W1H4V/iRE9/kz0Xwl/yJeif9g+D/wBFrWvWR4S/5EvRP+wfB/6LWteuSfxM2jsgoooqCgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP9Y/5L74c/7BN1/wChCvQK8/1j/kvvhz/sE3X/AKEKqImdBZ/8lJ1n/sE2H/o68rn/AId/8jp4+/7Cy/8AosV0Fn/yUnWf+wTYf+jryuf+Hf8AyOnj7/sLL/6LFPoxdUcZo3/JAPEH/YQT/wBCgrrifCfhr4e6Hqus+H7W5+0W9vGzR2UTuztFu3EtjP3TznOa5HRv+SAeIP8AsIJ/6FBWv4//AOSLeGf+3T/0navTkuafL3k/yRyJ2jfyD/hP/hz/ANCl/wCU23/+Ko/4T/4c/wDQpf8AlNt//iq7Hxr41k8JTabDBpTalLqDOiIkpRtylQAAFbJO+sX/AIWR4j/6J7qn5yf/ABqsormjzKLt/iLejs3+Bkf8J/8ADn/oUv8Aym2//wAVR/wn/wAOf+hS/wDKbb//ABVa/wDwsjxH/wBE91T85P8A41R/wsjxH/0T3VPzk/8AjVPlf8v/AJMguu/4GR/wn/w5/wChS/8AKbb/APxVH/Cf/Dn/AKFL/wAptv8A/FVr/wDCyPEf/RPdU/OT/wCNUf8ACyPEf/RPdU/OT/41Ryv+X/yZBdd/wMj/AIT/AOHP/Qpf+U23/wDiqP8AhP8A4c/9Cl/5Tbf/AOKrX/4WR4j/AOie6p+cn/xqj/hZHiP/AKJ7qn5yf/GqOV/y/wDkyC67/gZH/Cf/AA5/6FL/AMptv/8AFUf8J/8ADn/oUv8Aym2//wAVWv8A8LI8R/8ARPdU/OT/AONUf8LI8R/9E91T85P/AI1Ryv8Al/8AJkF13/AyP+E/+HP/AEKX/lNt/wD4qj/hP/hz/wBCl/5Tbf8A+KrX/wCFkeI/+ie6p+cn/wAao/4WR4j/AOie6p+cn/xqjlf8v/kyC67/AIGR/wAJ/wDDn/oUv/Kbb/8AxVH/AAn/AMOf+hS/8ptv/wDFVr/8LI8R/wDRPdU/OT/41R/wsjxH/wBE91T85P8A41Ryv+X/AMmQXXf8DI/4T/4c/wDQpf8AlNt//iqP+E/+HP8A0KX/AJTbf/4qtf8A4WR4j/6J7qn5yf8Axqj/AIWR4j/6J7qn5yf/ABqjlf8AL/5Mguu/4GR/wn/w5/6FL/ym2/8A8VR/wn/w5/6FL/ym2/8A8VWv/wALI8R/9E91T85P/jVH/CyPEf8A0T3VPzk/+NUcr/l/8mQXXf8AAyP+E/8Ahz/0KX/lNt//AIqj/hP/AIc/9Cl/5Tbf/wCKrX/4WR4j/wCie6p+cn/xqj/hZHiP/onuqfnJ/wDGqOV/y/8AkyC67/gZH/Cf/Dn/AKFL/wAptv8A/FUf8J/8Of8AoUv/ACm2/wD8VWv/AMLI8R/9E91T85P/AI1R/wALI8R/9E91T85P/jVHK/5f/JkF13/AyP8AhP8A4c/9Cl/5Tbf/AOKo/wCE/wDhz/0KX/lNt/8A4qtf/hZHiP8A6J7qn5yf/GqP+FkeI/8AonuqfnJ/8ao5X/L/AOTILrv+Bkf8J/8ADn/oUv8Aym2//wAVR/wn/wAOf+hS/wDKbb//ABVa/wDwsjxH/wBE91T85P8A41R/wsjxH/0T3VPzk/8AjVHK/wCX/wAmQXXf8DI/4T/4c/8AQpf+U23/APiqP+E/+HP/AEKX/lNt/wD4qtf/AIWR4j/6J7qn5yf/ABqj/hZHiP8A6J7qn5yf/GqOV/y/+TILrv8AgZH/AAn/AMOf+hS/8ptv/wDFUf8ACf8Aw5/6FL/ym2//AMVWv/wsjxH/ANE91T85P/jVH/CyPEf/AET3VPzk/wDjVHK/5f8AyZBdd/wMj/hP/hz/ANCl/wCU23/+Ko/4T/4c/wDQpf8AlNt//iq1/wDhZHiP/onuqfnJ/wDGqP8AhZHiP/onuqfnJ/8AGqOV/wAv/kyC67/gZH/Cf/Dn/oUv/Kbb/wDxVH/Cf/Dn/oUv/Kbb/wDxVa//AAsjxH/0T3VPzk/+NUf8LI8R/wDRPdU/OT/41Ryv+X/yZBdd/wADI/4T/wCHP/Qpf+U23/8AiqP+E/8Ahz/0KX/lNt//AIqtf/hZHiP/AKJ7qn5yf/GqP+FkeI/+ie6p+cn/AMao5X/L/wCTILrv+Bkf8J/8Of8AoUv/ACm2/wD8VR/wn/w5/wChS/8AKbb/APxVa/8AwsjxH/0T3VPzk/8AjVH/AAsjxH/0T3VPzk/+NUcr/l/8mQXXf8DI/wCE/wDhz/0KX/lNt/8A4qj/AIT/AOHP/Qpf+U23/wDiq1/+FkeI/wDonuqfnJ/8ao/4WR4j/wCie6p+cn/xqjlf8v8A5Mguu/4GR/wn/wAOf+hS/wDKbb//ABVH/Cf/AA5/6FL/AMptv/8AFVr/APCyPEf/AET3VPzk/wDjVcp8Q/Fura94egtdS8LXujxJdLIJ5y+1mCONvKLzyT17VUKfNJJx/wDJiZSsrp/gdB450nTtL8aeCv7M0+1s/M1D5/s8Kx78SQ4zgDOMn86t6z/yX/w//wBg9/8A0GeuU8W+LdW1TxD4curzwte6fLY3XmQwSl9102+M7Vyg5+UDgH7wo1Dxbq0/xP0vWJPC17DeW9q0cenMX8yZcS/MPkzj5j/Cfun8HGnPlV+z6g5xu7d0dXo3/Jf/ABB/2D0/9Bgr0WvD9P8AFurQfE/VNYj8LXs15cWqxyacpfzIVxF8x+TOPlH8I+8Px9F8FeNZPFs2pQz6U2my6eyI6PKXbcxYEEFVwRsrnxFKaSl0SRrTnHVebKdv/wAks8Sf9dta/wDSq4rmv+bav8/8/ldLb/8AJLPEn/XbWv8A0quK5r/m2r/P/P5To/Cv8SFPf5M9F8Jf8iXon/YPg/8ARa1r1keEv+RL0T/sHwf+i1rXrkn8TNo7IKKKKgoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArz/WP+S++HP+wTdf8AoQr0CvP9Y/5L74c/7BN1/wChCqiJnQWf/JSdZ/7BNh/6OvK5/wCHf/I6ePv+wsv/AKLFdBZ/8lJ1n/sE2H/o68rn/h3/AMjp4+/7Cy/+ixT6MXVHGaN/yQDxB/2EE/8AQoK1/H//ACRbwz/26f8ApO1ZGjf8kA8Qf9hBP/QoK1/H/wDyRbwz/wBun/pO1eo/4i/xfojj+z8v1Nf4kf8AI6eB/wDsIH/0ZDXotedfEj/kdPA//YQP/oyGvRa4Kn8OHz/M6o/FL+ugUUUVzmgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUdOtFZniSwudU8N31jYeR59xEUX7QuYznqDkMORnqrD1BHBAL63MDx70mjZMbtwcEY6ZpLa4juoBNFv2EkDehQ8Eg8EA9q82tPh1rSak13O2nbY9Q+2JF5rETqVgBhk2RIoXdC0nCn59hxwwbqdEuI/D2mppN8l3JcRyyMXt7C4ljO+RnGHEeDwwz6HPpQBsyatYxanHp8lwi3MkUkyp/sxlAxJ6DHmpweefrVlJopM+XIjYAJ2sDgHoa81/4Vtfy61pUtzbaQbew3rcT72aW+DXMUu6RfLxnEbZBY/Mx5xzVqL4fXtjps0OnJpkcstjc2zgp8khkuA6BhsIIEeV5BAJ+6w4oA9BjljmjEkLrIjdGU5B/Gs1PEWmya0dKWaT7SHMYJhcRtIE3lBJjaWC87Qc4B9DjA8MwS+EF1ODWFmke9vftcQsrSa4VEMUaYLRwqgYtG7EBR94HvU9p4fvxrltMDbjTYdSl1SORmcTsZYHTyzGVG3BlY53ZwoGOTgA6yiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK86+Nn/Il2n/YQT/0XJXotedfGz/kS7T/ALCCf+i5K6MN/GiZVfgYfEj/AJHTwP8A9hA/+jIaNZ/5L/4f/wCwe/8A6DPR8SP+R08D/wDYQP8A6Mho1n/kv/h//sHv/wCgz1vD4F/hl+pnL4n6oNG/5L/4g/7B6f8AoMFHw3/5HTxx/wBhAf8AoyajRv8Akv8A4g/7B6f+gwUfDf8A5HTxx/2EB/6Mmon8D/wx/QI/EvVl63/5JZ4k/wCu2tf+lVxXNf8ANtX+f+fyult/+SWeJP8ArtrX/pVcVzX/ADbV/n/n8pUfhX+JDnv8mei+Ev8AkS9E/wCwfB/6LWtesjwl/wAiXon/AGD4P/Ra1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/AGCbr/0IV6BXn+sf8l98Of8AYJuv/QhVREzoLP8A5KTrP/YJsP8A0deVz/w7/wCR08ff9hZf/RYroLP/AJKTrP8A2CbD/wBHXlc/8O/+R08ff9hZf/RYp9GLqjjNG/5IB4g/7CCf+hQVr+P/APki3hn/ALdP/SdqyNG/5IB4g/7CCf8AoUFa/j//AJIt4Z/7dP8A0navUf8AEX+L9Ecf2fl+pr/Ej/kdPA//AGED/wCjIa9Frzr4kf8AI6eB/wDsIH/0ZDXotcFT+HD5/mdUfil/XQKKKK5zQKKKKACiiigDG1u4vGu7PTtPuPsr3IkklnChmSNAAdoPGSzoMkHHPFVx4ftiB5l5qjtjlv7UuFz74VwB+AFS6h/yOOmf9eF3/wCjLetCuiLtFWMXq2Zf/CP2n/Pzqn/g2uv/AI5R/wAI/af8/Oqf+Da6/wDjlalFPml3CyMv/hH7T/n51T/wbXX/AMco/wCEftP+fnVP/Btdf/HK1KKOaXcLIy/+EftP+fnVP/Btdf8Axyj/AIR+0/5+dU/8G11/8crUoo5pdwsjL/4R+0/5+dU/8G11/wDHKP8AhH7T/n51T/wbXX/xytSijml3CyMv/hH7T/n51T/wbXX/AMco/wCEftP+fnVP/Btdf/HK1KKOaXcLIy/+EftP+fnVP/Btdf8Axyj/AIR+0/5+dU/8G11/8crUoo5pdwsjL/4R+0/5+dU/8G11/wDHKP8AhH7T/n51T/wbXX/xytSijml3CyMv/hH7T/n51T/wbXX/AMco/wCEftP+fnVP/Btdf/HKytb8bwaHNrEU1nJI+nWi3EQVwPtJJAKj+7gtHkn+/ntWzrWqpo2jzX0ihyu1Y4y4QPIzBUXceBlmAz2zmlzPuFkR/wDCP2n/AD86p/4Nrr/45R/wj9p/z86p/wCDa6/+OVQuPGFvFZ6TcwW7TRawqrZkOBmZgCsbf3eNxJ5xsYdcA6um6muoyXyLGY/sd01sSTncQqtn/wAe/SjmfcLIh/4R+0/5+dU/8G11/wDHKP8AhH7T/n51T/wbXX/xysSLx/byx2YFjIJrie5ieIyD90IY2k3E453LsIH+37GprHxr/ac1pb2Omu9zcac948bTKohdZFjMZY+jF8kdAnAOQKOd9wsjV/4R+0/5+dU/8G11/wDHKP8AhH7T/n51T/wbXX/xysiz8aPdX1pC1gkMVw2xZpLjaJj5jJmElAsi/KG+8rFWBCnIzsa54g0zw3Ypea1c/ZoHkESv5bPliCQMKCeimmpSeiE0kRT6RdWkLTaJqN5FcIpKx3Nw9zHKccKwkYkD3Ug1uafeLqGmWt7GMJcwpKoznAZQf61xXgLx7a+LbCKC4miXWVjeW4toYnVUUPtBBbI6Fe561b0O6ceFdJilna2gistOk85n8lTlhuXzOQchQCmBncBn5/lc6ctnugjJLY7Kisj/AIS3w5/0H9L/APA2P/Gj/hLfDn/Qf0v/AMDY/wDGsOSXY25l3Neisj/hLfDn/Qf0v/wNj/xo/wCEt8Of9B/S/wDwNj/xo5Jdg5l3Neisj/hLfDn/AEH9L/8AA2P/ABo/4S3w5/0H9L/8DY/8aOSXYOZdzXrzr42f8iXaf9hBP/Rcldd/wlvhz/oP6X/4Gx/41wfxe1zSdT8I2sOm6pZXcq3yOUguEkYL5cgzgHpyPzrfDxkqsboyqyXIy98SP+R08D/9hA/+jIaNZ/5L/wCH/wDsHv8A+gz1R8f65pN54u8HTWeqWVxFb3xeZ4rhGWJfMiOWIPA4PX0NGra5pMnxv0O/j1SyezisWSS4W4Qxo22bgtnAPI/MVvCMuRafZl+pnJrmfqi9o3/Jf/EH/YPT/wBBgo+G/wDyOnjj/sID/wBGTVD4bu7a++O2u3NlcRXMD6eu2WFw6tgQA4I4PIIqb4b/API6eOP+wgP/AEZNSn8Ev8Mf0HH4l6svW/8AySzxJ/121r/0quK5r/m2r/P/AD+V0tv/AMks8Sf9dta/9Kriua/5tq/z/wA/lTR+Ff4kOe/yZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/ANFrWvXJP4mbR2QUUUVBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8l98Of9gm6/9CFegV5/rH/JffDn/YJuv/QhVREzoLP/AJKTrP8A2CbD/wBHXlc/8O/+R08ff9hZf/RYroLP/kpOs/8AYJsP/R15XP8Aw7/5HTx9/wBhZf8A0WKfRi6o4zRv+SAeIP8AsIJ/6FBWv4//AOSLeGf+3T/0nasjRv8AkgHiD/sIJ/6FBWv4/wD+SLeGf+3T/wBJ2r1H/EX+L9Ecf2fl+po/FO6hsfFHg27un8uC3vGlkfBO1VeEk4HJ4Fbv/C0/B3/QY/8AJWb/AOIro7/SdO1Ty/7T0+1vPLzs+0QrJszjOMg4zgflVP8A4RLw5/0ANL/8Ao/8K4VOm4KM09Dp5ZqTa6mR/wALT8Hf9Bj/AMlZv/iKP+Fp+Dv+gx/5Kzf/ABFa/wDwiXhz/oAaX/4BR/4Uf8Il4c/6AGl/+AUf+FK9Ds/w/wAh/vPIyP8Ahafg7/oMf+Ss3/xFH/C0/B3/AEGP/JWb/wCIrX/4RLw5/wBADS//AACj/wAKP+ES8Of9ADS//AKP/Ci9Ds/w/wAg/eeRkf8AC0/B3/QY/wDJWb/4iorvxd4P8WWUulfaZL9JAHeCK1uNzBWB42rng4PH8q3P+ES8Of8AQA0v/wAAo/8ACsnxJHo3hDRzqOnWekaZeM6xQTyWZCknkqfKXd90N+IFVH2TkuVO/wDXkTLnUXzWsVVWx0rxG9zp9ndHFvqFxPEkUm+aXfbltgf72cADb8pPSsfQfH97feNdTsrjSNaNo8ltHbwmxUNZblwzTYOVBPzAkngGtDQfEkHiDxivkXltdeRb3fl/Z4pU2wtJb7N+8DL8NnHHFdPbaTZWmqXuo28Oy6v/AC/tEm9jv2LtXgnAwPTFaSairSWtv1M466xKPiLUr+wS2XTER5JGYyExGZkQDkiIOrNyVB25IyOD2ll12C38J/27KVkhFoLnEJJEmV3AISATnIAyATkcVbvtMsdUhWLU7K3vI1bcqXESyAHGMgEdcEj8agl0nzbhC15N9ljZGWy8qExKUIK4zHuGCoI+bgjjFc5qc7L44ltvCkWrSwQTTRXD2t3bxllJcA/MmeQuAshyMiMlv4cHd0zVJ7rWL2wuBC32WC3fzIs4dpA27GSePl4+tXhYWYujci1g+0MSTL5Y3nICnnr0VR9FHpVWTRYk2DTJm0sKixkWcMI3KowqncjcKM4AxjJoAoz+IJ4oA4hjJ/tZLDnP3S4Xd9eazrrXddtGvlaWymMGoRWUflWMhY7445N23zeeHxjI6Zz2roE0DSVu/tZ02ze7JDNcm2TzHYYO4sB1yAfwqa50rT72GWK8sLa4jmkEkiSwqwdwAAxBHJAUDPoB6UALp0k82nwyXf8ArmGX/cmLv/cLMR+Zq1UNraW9jbJb2VvFbwJnbFCgRVycnAHA5NTUxBRRRQAUUUUAFFFFAGTf+GdI1S4ee+sxLI4YM3mMMhozGRwf7pI+uD1AIWbSp728iOpyWdzaQSmWKAWzqwOCq5JkKtgMeq4zzgEDHLeK/Fer6Rfa3b2bpn7GPsBMYPlSqm9yf73yFnAP/PI+tdL4l1KfT9HAsd5vbqRbe3EaB2DN95gp4JVA74PB2Uhjm8LaM0TxmyGxldQPMf5N8nmMU5+Ql8NlcEFVx90Yf/Ztza3Ur6TPa28VxJ506zW7ys8hABYN5gA4CjGO1czdeL75tP0yeF1hkkjZNVjMWf7P2uEknPsrh1weCPm6I2ek0O/nvptWW4YMLa/aCLAxhAiED35Y0AMTwnokcxlSxAcgAnzH7K6ev92Vxn3H90YY/g7QnhuIjZFUuUdJQk8i7lcIGGQ3APlJnHv/AHmzyjeMntp7ldQ8QiNcsw8hYHwfMCrEu4KYXOcFZlbox3Daxpuq+MNe0+zvUFxbTXEmlxvaywIGjW4EXmSsp6MChZ1B4xEfWjQNTsU8LaVHNHII7ljG6PiS9mdXZDlGZS5DkHGC2SNq/wB0Y2K4C58V6vFq82nq6Fm1aARSeWPltfOSOVfchioz1HnD0rrNcvdTsLFJdF0j+1pzIFaD7SsG1cH5tzcHkAY9/amtXZCegvh/Q7bw3oVvpNi8skFvu2tMQWO5ixyQAOrHtWVo1mE8I6Vc5jP2qw0+2kAkEbFNwBBZiR0kPAAY8gHJXGT8LdZ13UvDtqmqWMslr5cjJqs14JGnbzSNpQ/MMcjJP8PuK0NClY+HrFFjNyYNK06dbePlyQWOcPlAPk6qN/B7hK2cZJtN9SLp2Lf/AAqzwd/0B/8Ayam/+Lo/4VZ4O/6A/wD5NTf/ABdZH/CyPEf/AET3VPzk/wDjVH/CyPEf/RPdU/OT/wCNUcuJ/m/8m/4JV6Xb8DX/AOFWeDv+gP8A+TU3/wAXR/wqzwd/0B//ACam/wDi6yP+FkeI/wDonuqfnJ/8ao/4WR4j/wCie6p+cn/xqjlxP83/AJN/wQvS7fga/wDwqzwd/wBAf/yam/8Ai6P+FWeDv+gP/wCTU3/xdZH/AAsjxH/0T3VPzk/+NUf8LI8R/wDRPdU/OT/41Ry4n+b/AMm/4IXpdvwNf/hVng7/AKA//k1N/wDF1xfxR8F6B4c8L293o1h9mne8WJn86R8qUc4wzEdQK3f+FkeI/wDonuqfnJ/8arlPiH4t1bXvD0FrqXha90eJLpZBPOX2swRxt5ReeSevataMa/tFzPT1/wCCZ1HT5XZfgXvG3gvQNI8UeFbTTrDyYNQvPKuU86RvMXfEMZLEjhm6Y60an4L0C3+L+j6JDYbdOubNpZYfOkO5gJed27I+4vQ9qo+LfFurap4h8OXV54WvdPlsbrzIYJS+66bfGdq5Qc/KBwD94Vtabda14j+Lej6xe+G7/SoLe3eBjNG5UfJKQSxRQMlwMVp+9jBOT6Pr16E+45WS6rodzongvQPDl693o1h9mneMxM/nSPlSQcYZiOoFcv8ADf8A5HTxx/2EB/6Mmr0WvOvhv/yOnjj/ALCA/wDRk1cUZSlTm5O+35m8klKKRet/+SWeJP8ArtrX/pVcVzX/ADbV/n/n8rpbf/klniT/AK7a1/6VXFc1/wA21f5/5/K1o/Cv8SJnv8mei+Ev+RL0T/sHwf8Aota16yPCX/Il6J/2D4P/AEWta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/wAl98Of9gm6/wDQhXoFef6x/wAl98Of9gm6/wDQhVREzoLP/kpOs/8AYJsP/R15XP8Aw7/5HTx9/wBhZf8A0WK6Cz/5KTrP/YJsP/R15XP/AA7/AOR08ff9hZf/AEWKfRi6o4zRv+SAeIP+wgn/AKFBXUeJNA1PxH8I/Dlpo1t9pnSO1lZPMVMKICM5YgdSK5fRv+SAeIP+wgn/AKFBXrnhL/kS9E/7B8H/AKLWu+tNwfMukn+SOanFS0fY5H+2fir/ANC1pf8A38X/AOPUf2z8Vf8AoWtL/wC/i/8Ax6vRaK5fbL+Rfj/mb+zf8zPOv7Z+Kv8A0LWl/wDfxf8A49R/bPxV/wCha0v/AL+L/wDHq9Foo9sv5F+P+Yezf8zPOv7Z+Kv/AELWl/8Afxf/AI9R/bPxV/6FrS/+/i//AB6vRaKPbL+Rfj/mHs3/ADM86/tn4q/9C1pf/fxf/j1L/avjiWN18U6RplhpuMyXA1A2u05G394jsRk8dOema9ErO1vRxrdklsb++sNsgk8yxm8pzgEYJweOensKarRvrFL7/wDMmVN20bOUglvpfEbfZBY/als74R41CS6RZ99vlXyoKAHb8q9ATwO+B4ZHi7/hZPiDzP7F8zzLP+0sebt2bOPJ99uc7uM47V1Nl4fGheMbPGqanqHnWFz/AMf9x5uzEkH3eBjOefoK6atHNJadV+pmovqc34wNyLe0+zNeKokZnW2Sch/lOFZoP3idcg4ZeMEcirU97qMPgxbm2tZ31R7VBHBKAziZgAN+0AYDH5iAAACeAK2qovpmlHUlu5bKzN8x3LM0S+aSBjIbGeBisDU5KSXxPH4fjsrOK9/tmzuZI0lkO+OaDbuDO5G1m2Oqg95V5+XfUOqS6m983ktrC6eIbd4VaG5G8+W+Vdov3qN90k4YZGGGSK7xrqBZDG08YcdVLjI79KloAxLuS8l8Eb/9Mt7x7Nd+1PNniYqN2VTbuYc524JwdvOK5mW6v/8AhHxCE1yKd7qSK2ljS5kWMbFPnNlPNKqS2EfO5sjJXBXtW0jTXv8A7c+n2rXeQftBgUyZAwDuxnpVgzxLOsBlQSsu4RlhuI9celAHnlvN4rLWltKNR2W81xLJKY2zMskEpiUnHIRwwx2/deorS8Ly+IZNcsotWF4La00+W2kaZCBPKHiKyscYJMZHP97zR2NdrRRYAooopiCiiigAoorm/Fdjqk91pl9o0DTzafI84jEoQScAFOSB8yl1GeASDQB0lU4dMggvWukkujIxJKvdyunPohYqPwHHauf0e4Xwr4aNhql5byaoj3M0cM10iSXRaaRkI3NxvyOvTOOMVQtdA8RWui3mlTMk088sNxb6jFJhbadv9bJtY5OGTzNuMMZSvC5whnd1TutMgu7hZ5ZLpXUAARXcsa8HPKqwB/EVxV74e1a4gsEm02d44rQxXKR3EUnmSidWL7ZDtkDFS5DYOCejYFbFtdR6d4T/ALM1Oey0/UZIJVitGuFQ4ZmEeAXO3IxwGKqeAcAUAdRS15oPCWvXFsLS8ilNvb6bJpsIFyuShlhYNndnOwFCTzmIn+IZsjSfEP8AxMLzVNI/tS6uorSFIGmjMSmJpVZypdQy8iXacZMgHBBKlwPQqK4YaDfw6zpc0Gn3E5t4rWI3F5JE5SNPvkurh0kxuyF3o/HZmx02uWWp39ikWi6v/ZM4kDNP9mWfcuDldrcDkg59vemtWJk2k/2b/ZkX9h/ZPsPPlfY9vldTnbt465zjvmuR8Pa6lzouiWCaLrqSeXZRm5ex8y3xGyncMtgA8/OBkDB/hFN+Fuja5pnh21fVL6WO1McippU1mI2gbzSdxc/Mc4JwR/F7Creg22pP4a0wpcWBJsrTbu0qR2xx5Q8zeQSrc52kL94gA1vZLmVzO7djvqK86/sb4q/9DLpf/ftf/jNH9jfFX/oZdL/79r/8ZrH2K/nX4/5G3tH/ACs9Forzr+xvir/0Mul/9+1/+M0f2N8Vf+hl0v8A79r/APGaPYr+dfj/AJB7R/ys9Forzr+xvir/ANDLpf8A37X/AOM0f2N8Vf8AoZdL/wC/a/8Axmj2K/nX4/5B7R/ys9Frzr42f8iXaf8AYQT/ANFyUf2N8Vf+hl0v/v2v/wAZrlPiHp/jW08PQP4q1eyvbM3ShI4EAYSbHweI14xu79+lbUKSVVPmX9fIzqTbg1ZnV/Ej/kdPA/8A2ED/AOjIa9FrzI+CvG+p+IdHv/EWr6bdxabdJMoTKsF3qWxtjGSdo616bWNayjGKd7f5lwvdtoK86+G//I6eOP8AsID/ANGTV6LXnXw3/wCR08cf9hAf+jJqKf8ADn8vzCXxxL1v/wAks8Sf9dta/wDSq4rmv+bav8/8/ldLb/8AJLPEn/XbWv8A0quK5r/m2r/P/P5W1H4V/iRE9/kz0Xwl/wAiXon/AGD4P/Ra1r1keEv+RL0T/sHwf+i1rXrkn8TNo7IKKKKgoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArz/WP+S++HP+wTdf+hCvQK8/1j/kvvhz/sE3X/oQqoiZw+kfCvXYfj7qerDVoLOGOaXUTLaMGmWO5a4WMKJImTdlCGBGADwSenQeA9Fv5/F3jZIvE+q27RaoqvJFFalpjsHzNugIB/3Qo9q2NJ8c+Hb34x6rpNtqO++ltILJIvIkGZreS7aZclcfKGBznBzwTR8O/wDkdPH3/YWX/wBFirbfUhJdDzvSdMu2+CGuXC65fpEl8oa1VLfy3O6Hkkxb88jowHA4659Q8MeH9Sk8I6O6eL9ahVrGAiNIbIqg8scDNuTge5J964DRv+SAeIP+wgn/AKFBXrnhL/kS9E/7B8H/AKLWurE6J/4n+SMqW69Ct/wjmqf9Dprn/fmx/wDkaj/hHNU/6HTXP+/Nj/8AI1dBRXDc6LHP/wDCOap/0Omuf9+bH/5Go/4RzVP+h01z/vzY/wDyNXQUUXCxz/8Awjmqf9Dprn/fmx/+RqP+Ec1T/odNc/782P8A8jV0FFFwsc//AMI5qn/Q6a5/35sf/kaqmqeENZv7B4Lfx3rlvIxBEoitAVwf9iFT7dce1dXUNzd21lD515cRW8QON8rhVz9TRcLHC6D4Y1Pw54xg/tXxTqHiD7RYXHl/bVUeRtkgzt2+u4Z/3RWjc2V/ZeK31h5pH07ywjwq8srD5cDZEi/3uSSWGMnAOTVqXUrHUPGOn/YLy3uvLsLrf5MqvtzJb4zg8dD+VT3viHR9NnMOoana20oGSksoUgYz0+mT9AT0Brb7K/rqZ9WY+q2Wp67qmn32kTtbWtvNEziZpreQhZVaQGNlwwMYKjgdTk44pNO07WNHvHvdVvXuLUSySeXC807Ir4CxBApLBD/F1OTkDFdNcXMNpbvcXUqQwxjLSOwCqPrVSLXtLuIy1tqFtMQrNsSZd2FzngnjGDnPTHNIDnNS0O916S+ubCXy7e5GBDcedblmVVA3AqCBlTzg9e/SrWh2d/4cW5m1y6urzz9iAxGW63OC5Z9ix5j3AjjJAwBngZ37jUbSzs1ury4jghYDDyOACSMgD1P0qp/wlGhfZPtX9sWP2fdt83z125wG65/usDn0OelAHPa1oeva1rMGo6Ve/ZrMOpMb3E8DSxeWwaNkK5UsxHzDGBzgkClvfCerz6rp1/aXENqbOIq0IupG8weaW8syFd20rxkYx6FflO9L4ksk+zyQiW5tp5Fi+1QgGJHaTylUnPJ3nGBkjvgVds9RstQEhsbqK4EbbX8tw200AWqKzZvEOkW88sM+pWqSw/fQyjI5Axj1yQMe49RUdn4l0y9vPs0Fwu5iRGxYbZTkj5Tn5s4J47DNMRrUUUUAMEsZfaJFLZxjdz0z/Ij86huL+1tbeSeedVjjGWI+Y9cYAHJOeMDknjrXML8P7aOdJo54klWIRl1tgGJ23Cls57/aB/3x78SQ+CW0+4ubrRb2CwupYnjjlWyDeXujgTONwzjyC2Dxl/blajOjs7+21CFZbSUOp3DBBVgVYqwKnBBDAggjggipy6qyqzAFjhQT1rldM8ISaNqiaok0M0kcb+ZFBblWnYg/xSSthieS2QWP3mxxRd6Pea94jgvp7P8As+G3SLm5jjklYpMJMIUkOwHaASc59KAOoM0S/ekQc45YdcZ/lzThIhIAdckZAz29a5X/AIQKyMcCubdvJMRJNqvzFJxKx69WA2n8+elVH8CeS+nxwOJNvkwXM6xqmbZItrwnnJVyF4HT8OQDtmYKuWIUepNNM0YVmMigKcMSw4PofzrHv7dtauoLW70y4jt7e5ExlmELxy7c4GA5bnORlfwFYi/DtE0+4theRM0rRkSvDISdnmcuPNwzHzDkjAJzkEHAAOwnu7e2ikkuJkjSMAuWb7uemakd1jUs7BVHUk4ArjY/h8ES8330U0lxC8YlktiTuZkfLKHCEAxgABVwMAHjnWvra48QRQxS2EtibaYTr9ujimhlIBXayJKSfvZHIwQp7YoA2bi5htYGmuZVjjT7zMcAdv6093WNCzsFVRkknAAri4Ph/NBYizbVIZYI7SS3hV7PJDO0Lbm+fDAGHhRjhuvGa27i3fX/ACIr7TJ7SK3nWci6EMiy4yNuFdvXOSO1AG3XnvgDTfh/rENi2lyWt1rdhDDNdRx3bl4pgASSm7HD9eMA8V2NjpCWnhm30aSVpEhs1tWlUbCwCBdw64Pf2rzDwf8ABg391pniDxBqwaCK2WSxg02L7M4Ejeb++kHMmC2PeqcpRi7MSinLVHtlFFFc5sFFFFABRRRQAV518bP+RLtP+wgn/ouSvRa86+Nn/Il2n/YQT/0XJXRhv40TKr8DPRaKKK5zUK86+G//ACOnjj/sID/0ZNXotedfDf8A5HTxx/2EB/6Mmrop/wAOfy/Myl8cS9b/APJLPEn/AF21r/0quK5r/m2r/P8Az+V0tv8A8ks8Sf8AXbWv/Sq4rmv+bav8/wDP5W1H4V/iRE9/kz0Xwl/yJeif9g+D/wBFrWvWR4S/5EvRP+wfB/6LWteuSfxM2jsgoooqCgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP9Y/5L74c/7BN1/wChCvQK8/1j/kvvhz/sE3X/AKEKqImY9l8JPDb/ABj1fUbxZ77bDHqJtbsRyQvJcyXKuGQpyo2KVHUHkk0eA/CPhu88XeNobvw9pU8VtqixwJLZRssS7Adqgr8o9hWfpvxeiPxw1XSrjRZ1jf8A4lpmt2e4cfZXuW3iJIyzbt+MD7uM5I6aHgPxPYWvi7xtLLb6qy3GqK6CLSLqRgNg+8qxkofZsGrfNYhcvQ5PSfDuiSfBDXL+TR7B7yK+VI7hrVDIi7oeA2Mgcn8zXqHhjwN4TuPCOjzT+F9FllksYHd30+IszGMEkkryTXl+k67aR/BDXLNob8yyXysrLp1wYwN0PWQJsB4PBIPT1FeoeGPGGmweEdHie21otHYwKSmh3rqSIwOGERBHuDg11YjZ27/ojKlur9jU/wCEB8Hf9Cnof/gth/8AiaP+EB8Hf9Cnof8A4LYf/iaP+E10v/n11z/wQX3/AMZo/wCE10v/AJ9dc/8ABBff/Ga4veN9A/4QHwd/0Keh/wDgth/+Jo/4QHwd/wBCnof/AILYf/iaP+E10v8A59dc/wDBBff/ABmj/hNdL/59dc/8EF9/8Zo94NA/4QHwd/0Keh/+C2H/AOJo/wCEB8Hf9Cnof/gth/8AiaP+E10v/n11z/wQX3/xmj/hNdL/AOfXXP8AwQX3/wAZo94NA/4QHwd/0Keh/wDgth/+JqG6+G/gq9tmgm8K6QI2xuEVmkZODnqoB61N/wAJrpf/AD665/4IL7/4zVTVPiNo2k2D3dxZ640aEAgaJdoeTjq8aj8M5o94ehT03wb4e8I+MbX/AIRvSbfTvtVhc+d5II8zbJBtz9Nx/OtHUvDFlqkkz3Es6mZizbGUYzA8PGQf4ZCfrjtxWLoPjrTPGnjGD+yrfUIfsdhceZ9ttGgzvkgxt3dfunPpx61paz4vi0e6libTrq4EOQ7xGMDIiabHzMD9xG/HA78a/ZX9dTP7TLd1aX+pQzWFzHHa2b8C4tbxvOwDkfKYwOcYIyRgkc1n6f4D07TZJJIbq8Z5IpoGLMgHlyu0jIFVAAN7lgcZHAzjitzUNQj07TJb2UFkjUHaGVSxJwACxAySQOtYNj46stReWCK1uobmO2muGSVF+VYpGjY43A/fQjHB+lLQDRFjeTzWsFzbwR2lnKHhljuy0jbQQu5TGByDzhuKpp4I01NPazE115bWzWxJdc7TAkGfu9dsYP1z24q9qWuLpmjQ37W09yJduEhTJGRnJ54AA69u/HNZw8UTpd3ErRxXdhHCJD9k+ZomZkEaFy2xmdXLYGNoA5IYEgFo+Fof7TtrxNQvUFtNLOtv+6aMvI5diQyE5+YqCCCFJAIySW2WiXHh/wA0aIi3a3DbpEurkQrGR02LHERk5OTjJwMk1BB4zWdpIhpV2twsohWIvH87+ZLGed2AA0L8ntg47VoeH9fi8Q2LXMFtNbqpTCzbdxV40kU/KSPuuPxzRoBnP4Jtp9di1t7++j1CIyNG6vG4hMm3cAWjyRhdoDZABOADgiaDwbYW+qW+orPdNeW7EpMzqWwxy4Py8hs4I+h4IBEU/ja2i8Qro0Vjcz3UzSJblGTZK0eN43bsAgNnB54IwDgGLT/Gf2rxBDps9qyG6LiHbg42lidzZ252r0BJPOMgEg0DU6uiiimI5u48ZW7aTNqGk27XsFuzLKzMYskdETIJd2JChR34JBxm1L4s0qHUhZO9x5pk8oEW0hTdvVD82McNIgJ6fMPfEb+C9EkuFuDDciZX8xZFvp1YMFKjkPngMwA7AnHWrkmgaZLMJXtsuHZwfMb7zSJIT1/vRIfw9CcrUehXtfFmlXuoxWUD3BllIEZa2kVWyHIO4jGD5UmP9w+2bN7rllYX8NnctIJZduNsTMq7nCLuYDAyxA59fTJpg8P2ELJNZwLFcwoqwSOzuqFRIFyu4ZA86TjPO7rwMVh4de71ZNQ1q5S6kiVFijt0kgQFX3gsvmMHIYAjPAxRqAj+MdJVUbN0wkYKu20lOcvsU/d6FyFB7k+nNKnjHRXK4uJAGtxcqxgcAqVDBQccuQc7B83XirY0DTAsai24iEYQeY3GyQSL37OAf06cVUl8J6cz2AhiWKCznjnCHcxZokKx4JPGM++cUagad/qMGmwpJc+ZiSQRIscbOzMegAAJ7Vj/APCdeHzbzTJel0hdEO2Nju3lghHHIOxseuPcZ0GsLy4vke+uLWa2hl82KNLZ0dSM7SX8wg4B/u8+1QjwvpS2klssU6wyYyi3coCgZwq/N8q/MRtGBjjGAKNQK0/jbR4jdJDLJPPaoXeFIm3EBlVsZHVS6g+n4HGvf6jBp0Ub3HmMZXEcccUZd5GwTgKOTwCfYAntVCPwno8NvLbw20kcEsZjMSXMoRQSCdqhsKcqDlcHOTnJNSNpVzfKE1q5guEjYPEbSKS2eN+RkOJSehI4xwSOhxRqBWl8Y6SNMF7aySXSNG0saxxNudVZFY4I7GVPz9jWnqGowabAktz5h8xxGixxl2dj0AAHtWZH4M0KFXWK0kVWga3Ci6lwiNsyFG75SfLQ5GDlc5q5FYXc0iHV7i1uVhcSRCC3eIq4zySZGzwTxRqBYi1G1m0lNTjlBs3gFwspBH7sru3YPI45rz/wd8X9Ft4dM0HxBa3ehv8AZEisrq8UeVe7CIiUIzj5hxnqK9CtrK3tNPisYIgttDEsKRklgEAwBz149a5HwB8NfC+mWFlr8dgbjULyzikaS6kMwiLgO3lq2QmWJPFEvhHH4j0KiiisTQKKKKACiiigArzr42f8iXaf9hBP/Rclei1518bP+RLtP+wgn/ouSujDfxomVX4Gei0UUVzmoV518N/+R08cf9hAf+jJq9Frzr4b/wDI6eOP+wgP/Rk1dFP+HP5fmZS+OJet/wDklniT/rtrX/pVcVzX/NtX+f8An8rpbf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K2o/Cv8SInv8AJnovhL/kS9E/7B8H/ota16yPCX/Il6J/2D4P/Ra1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/YJuv/AEIV6BXyvqz+O4/j2XtYtYmuF1aU2Edw0yxvbfaOgPaAjGSPl2+1XBXuRJ2PeNO0DR4Pitq95BpNjHdLp1pOs6WyBxJJLdiRwwGdzAAMepwM1n/Dv/kdPH3/AGFl/wDRYrHttV+JI8b6m6eHNGN42nWYljN821YxJc7CDjkkmTI7bR61j+DNS8fR+J/FzaZoOlT3EmoqbxJbwqsUmwcKccjHeqtoxX1GaN/yQDxB/wBhBP8A0KCvXPCX/Il6J/2D4P8A0WteAaZe+Ll+EGsQwaTp7aW14pmuGuSJEfMXAXuOF/M16L4e1b4mJ4X0tbPw1oslutnCIne/YMybBgkY4OK6sRqn6/ojKlo16HqNFef/ANsfFP8A6FfQ/wDwYN/hR/bHxT/6FfQ//Bg3+FcXKdFz0CivP/7Y+Kf/AEK+h/8Agwb/AAo/tj4p/wDQr6H/AODBv8KOULnoFFef/wBsfFP/AKFfQ/8AwYN/hR/bHxT/AOhX0P8A8GDf4UcoXPQKK8//ALY+Kf8A0K+h/wDgwb/Cmy6z8VhbyGLwtoZlC/Ip1A4Jz+HbNFgudNqH/I46Z/14Xf8A6Mt6nm0+yuCxuLSCUscsXiVsnaU5yP7rFfoSOhryH4W634p1Xxx/xU1zqlxdLZS/a4NQshbpaSGQblhx94fLD9M5713+oa1rEHiyK0t7SU6f8yyy/YZH2jyHkDqy5DfMqrjg5OACSDWv2V/XUze7NdtJ86SQXt5NeWsmc2c8UJixnIHCBjjtk9u9Og0PSbZNltpdlCu5m2x26KMsCGPA6kEg+uTWV4a1LWdQn3a3p7WUnkfPH5bhUfecAEkq3y4OR647VT8Q6x4ns9WlTSrSN7RFOx3tJpNz7AwBKZOCSRnGBtxnJFIDcfQorhyt/cPe2mcrZXEEDQp6YHlg8dufzp8OgaPbzSS2+k2MUkoxI6WyKX5B5IHPIB/AVzd9r/iWHUru3gsd0KzhUnWymZYo8nk4GXY8DChgM7iQBio5tX8WI1xJFb5k/s9LoR/YZWQSCIsY1JIOWcEYPzAY4yRQB2C6dZJJ5iWdur7t+4RKDu3M2c465dj9WJ7mq8mkKsaJptzJpaKACtnFCA+FCrncjdFUAYxxx2FaNFMRmt4e0eV2kuNLsp5pBiSWS2jLScgkk45yVB+oHpUyaTpybdlhartIK4hUYIOQenY8j3q5RQAUUUUAFFFFABRRRQAVBe3P2PT7i527/JiaTbnGcDOM/hU9FAHGp40v1nuI7jTLYGNTs2XTHc2LdgDlOBi5Azzyh454hn8ZyrZXh1WaHSfs8gRZbeRZGmbzpodi+YAqktDnLZAUnOMbq7iikM5bwp4ouNXunsL8WhuILdXaW1nEqyngMwwMBSTkAkHHYjmk1vxXc6TeX8dvaLcfZYnnbzJtg2pEJGAwpOT05Pv7V0lzbJd27QymRVbGTFK0bcHPDKQR+BpLS0jsoPKhaZlznM0zyt/305J/WgDlW8YXsF9qkL21pIljMVZzOU8tSyqpf5TgDdvY9l5wajvPH4ttLEnk232mY+XbAXGVnf7T5GU4yw6Px2P412tJQBU0m6a+0Wyu3aN2nt45C0ZypLKDkHuOa4Xw34/8QQaVpOnx/D3WpreOCGBb1ZI/LdAoXzBznaRz9K9Gqp4S/wCRL0T/ALB8H/otaJfCOPxGvRRRWJoFFFFABRRRQAV518bP+RLtP+wgn/ouSvRa86+Nn/Il2n/YQT/0XJXRhv40TKr8DPRaKKK5zUK86+G//I6eOP8AsID/ANGTV6LXnXw3/wCR08cf9hAf+jJq6Kf8Ofy/Myl8cS9b/wDJLPEn/XbWv/Sq4rmv+bav8/8AP5XS2/8AySzxJ/121r/0quK5r/m2r/P/AD+VtR+Ff4kRPf5M9F8Jf8iXon/YPg/9FrWvWR4S/wCRL0T/ALB8H/ota165J/EzaOyCiiioKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8/1j/kvvhz/ALBN1/6EK9Arz/WP+S++HP8AsE3X/oQqoiZ0Fn/yUnWf+wTYf+jryuf+Hf8AyOnj7/sLL/6LFdBZ/wDJSdZ/7BNh/wCjryuf+Hf/ACOnj7/sLL/6LFPoxdUcZo3/ACQDxB/2EE/9Cgr1zwl/yJeif9g+D/0WteR6N/yQDxB/2EE/9Cgr1zwl/wAiXon/AGD4P/Ra12YrZ/4n+SMKO69DXooorgOkKKKKACiiigAooooAw9Q/5HHTP+vC7/8ARlvWhWdrEkdr4m0m4ncJHJDcWqsxwN7mNwM+4iatGt/sr+upk92V7yws9RhEWoWkF1Grbgk8YcA9M4Pfk1JBbw2sCQWsUcMSDCxxqFVR7AdKkooEFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFQXgmNjOLQlZzG3lEAEhscdeOvrxU9FAHBwWGu3V3pi6vpN1JJDcK76iZoC8aK6sFVBJ8gYg7iN5KDbls/LZS08XpcrKbu4cGIFo2MG0OUnBHAzgEW+Oe5/2q7OilYZyunDWNK1SS517Un/sxVYF7qSFUUlICpyACP3hnH5DptqDUH1nU5b+48NXiPbmNzBLayQMJJViGxSTnjf1z+PFdjRQBxzWPiaO+1Rrea7WDzjJAoeE+YrMu7Zu6EJuChsDcOeKjvB4vbSxb28Vy0k/yCQyQBoE+09XOevkHHy7uR6812tFFgKekpNHotkl0sizrbxiRZCCwYKM5KkgnPpxXC+G9J+JraVpMtr4m0VNLMELR27WDGRYdoIUtnltvGfWu+vr2DTrGa7u5FjhhQszMccCn+HrZ7LwxpdrMCJILOGNwR0IQA/yol8I4/EaNFFFYmgUUUUAFFFFABXnXxs/5Eu0/wCwgn/ouSvRa86+Nn/Il2n/AGEE/wDRcldGG/jRMqvwM9FooornNQrzr4b/API6eOP+wgP/AEZNXotedfDf/kdPHH/YQH/oyauin/Dn8vzMpfHEvW//ACSzxJ/121r/ANKriua/5tq/z/z+V0tv/wAks8Sf9dta/wDSq4rmv+bav8/8/lbUfhX+JET3+TPRfCX/ACJeif8AYPg/9FrWvWR4S/5EvRP+wfB/6LWteuSfxM2jsgoooqCgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP9Y/5L74c/7BN1/6EK9Arz/WP+S++HP+wTdf+hCqiJnQWf8AyUnWf+wTYf8Ao68rn/h3/wAjp4+/7Cy/+ixXQWf/ACUnWf8AsE2H/o68rn/h3/yOnj7/ALCy/wDosU+jF1Rxmjf8kA8Qf9hBP/QoK9c8Jf8AIl6J/wBg+D/0WteR6N/yQDxB/wBhBP8A0KCvXPCX/Il6J/2D4P8A0WtdmK2f+J/kjCjuvQ16KKK4DpCiiigAooooAKKKKAIrq1t723e3vII54XGGjkUMp/A1l/8ACK6YAAjX8agYCR6ncooHoAJMCtmiqUpLZiaT3Mf/AIRbTv8Anrqf/g2uv/jlH/CLad/z11P/AMG11/8AHK2KKftJ9xcsexj/APCLad/z11P/AMG11/8AHKy9a0/TtIiicLqk5ZizqNXugUiUFnf/AFnOB27kgV1lUbrRrG/vhc38CXRWLy0jmRXRATkkAjqeM/7oqo1Hf3mxOKtojnnsbFNaXS1j1Np5NskLDWbrY0P8UhO/gg8be5K9iSGvZWf9lLdQR6g0j3zWaxvrV0BkTtFuJDn+7nGPati28L2drHFsmuWmheNo7h3BkRUG0IDjG3aSCMc7mPU5qWXQoZNN+xx3FxCBdNdLKhUurmUy8ZUjG4nqOlX7Raav8SeXyML7JYQNNHqC38E0EsaOE1q7dWV+jA7gc8EYIHI645p8EXh64Mflz6yBIUAZr68ULvOEyS/G7jH1HqK2D4et5LeRLm5uZ5ZZUlkncqHYrwo4UKAPQAd+5qNfCtgt5Bcq0geJYhyqHf5f3SWK7h0GdpGcUe0XdhyvsZM8WiRqhh/tqYPOkSsNQvArZfYWUl8EA+nXjsc0k1vpVtr11YXP9ppDb2n2nz/7Yujux95cb+uOevPPpW0PDsQiWJb27EUbq8MYZNsOHDjA288gD5skDpjNPvPD9pfXpup2l3+ZFJhWAHyBgB06EOQR3o9ou7DlfY5+0XRn0uC5v/7VtpZEeSWJNVu5RCqsVLMwfgZHX6+hp5/4RsFsz61hQSW+23u3aG2s2d/QHgmtSfwjp86xhmkBRXQsVjYsrOXI+ZTjknBGDz1qZvDVm1u0Jkn2tBJAfmGdrvvPbrmn7SPdhyvsjJuofDtm8guLnV1WNmQyDULwqWA3FQQ+CQATgeh7g1MmnaG7BDNq6SFo18p9Ru1bL/d4MnsfptPpV278MWt4ZFluLkQvK0wgUqFWRlILD5c9zwSRk9OmJ5NLM3iaHUZAixwQFFwxJdznBIxgbQzgcnPmHpS51bdj5fIxpLDTY/ECacRqZjYBTcf2xdYEpDMI8eZ/dUnOe6jvS/ZtA2sRNrJG7ahF/eYlO7bhDv8Am59Pr05rVk8NadK8kzx5upLgXH2vavmqwYFQGxwAFC49ODnmmjw7EqIiXt2qQtvt1DJiA7s/KNvPp82eMjuaOdd2Ll8jNFpoDTJH5+sAsVUlr+8AjZjhVYl/lJPGD7eoywQ+HjC0qz6wUDiNCL+8xIxJUBTvweQf59MVpDwtZ/2gl4808k4ZHd5AjGRlOQSxXI7cKQMADGKQ+FLQvcObictcY3krGcgNnDDZh+uMvuOO/ejnX8zDlfZBB4c0y4gSaOXVQrqGAfU7tSPqDJkfQ1J/wi2nf89dT/8ABtdf/HK0LCyj07T4bSAs0cK7VLkZ/Tj8BgDtVis3UlfRsvlXYx/+EW07/nrqf/g2uv8A45R/wi2nf89dT/8ABtdf/HK2KKXtJ9w5Y9jKg8NaXBcRzmCS4liOY2u7iS42H1XzGbB9xWrRRUuTe40ktgooopDCiiigAooooAK86+Nn/Il2n/YQT/0XJXotedfGz/kS7T/sIJ/6Lkrow38aJlV+BnotFFFc5qFedfDf/kdPHH/YQH/oyavRa86+G/8AyOnjj/sID/0ZNXRT/hz+X5mUvjiXrf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K6W3/AOSWeJP+u2tf+lVxXNf821f5/wCfytqPwr/EiJ7/ACZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/yX3w5/2Cbr/wBCFegV5/rH/JffDn/YJuv/AEIVURM5fTfi9EfjhqulXGizrG//ABLTNbs9w4+yvctvESRlm3b8YH3cZyR00PAfiewtfF3jaWW31VluNUV0EWkXUjAbB95VjJQ+zYNdRp2gaPB8VtXvINJsY7pdOtJ1nS2QOJJJbsSOGAzuYABj1OBms/4d/wDI6ePv+wsv/osVTtYhXPO9J120j+CGuWbQ35lkvlZWXTrgxgboesgTYDweCQenqK9Q8MeMNNg8I6PE9trRaOxgUlNDvXUkRgcMIiCPcHBrgNG/5IB4g/7CCf8AoUFeueEv+RL0T/sHwf8Aota68Ts7/wAz/JGVLdehW/4TXS/+fXXP/BBff/GaP+E10v8A59dc/wDBBff/ABmugorh0OjU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugoo0DU5/8A4TXS/wDn11z/AMEF9/8AGaP+E10v/n11z/wQX3/xmugpryJGAZHVASACxxknoKNA1MH/AITXS/8An11z/wAEF9/8Zo/4TXS/+fXXP/BBff8Axmug69KTcAwUkZPIGetGgamB/wAJrpf/AD665/4IL7/4zR/wmul/8+uuf+CC+/8AjNdBRRoGpz//AAmul/8APrrn/ggvv/jNH/Ca6X/z665/4IL7/wCM10FFGganP/8ACa6X/wA+uuf+CC+/+M0f8Jrpf/Prrn/ggvv/AIzXQUUaBqc//wAJrpf/AD665/4IL7/4zR/wmul/8+uuf+CC+/8AjNdBRRoGpz//AAmul/8APrrn/ggvv/jNH/Ca6X/z665/4IL7/wCM10FFGganP/8ACa6X/wA+uuf+CC+/+M0f8Jrpf/Prrn/ggvv/AIzXQUUaBqc//wAJrpf/AD665/4IL7/4zR/wmul/8+uuf+CC+/8AjNdBRRoGpz//AAmul/8APrrn/ggvv/jNH/Ca6X/z665/4IL7/wCM10FFGganP/8ACa6X/wA+uuf+CC+/+M0f8Jrpf/Prrn/ggvv/AIzXQUUaBqc3cePNFtLaW4uotYgghQySSyaFeqqKBksSYcAAc5rnvjZ/yJdp/wBhBP8A0XJXS+Pv+SbeJv8AsE3X/olq5r42f8iXaf8AYQT/ANFyV0Ye3tY+pnV+BnotFFFcxqFedfDf/kdPHH/YQH/oyavRa86+G/8AyOnjj/sID/0ZNXRT/hz+X5mUvjiXrf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K6W3/AOSWeJP+u2tf+lVxXNf821f5/wCfytqPwr/EiJ7/ACZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/yX3w5/2Cbr/wBCFegV5/rH/JffDn/YJuv/AEIVURM6Cz/5KTrP/YJsP/R15XP/AA7/AOR08ff9hZf/AEWK6Cz/AOSk6z/2CbD/ANHXlc/8O/8AkdPH3/YWX/0WKfRi6o4zRv8AkgHiD/sIJ/6FBXrnhL/kS9E/7B8H/ota8j0b/kgHiD/sIJ/6FBXrnhL/AJEvRP8AsHwf+i1rsxWz/wAT/JGFHdehr0UUVwHSFFFFABRRRQAUUUUAFFFFABRRWFLq2pX1/cW+jw28UFtIYpLu6y4ZwBkJGpBIBOCSw5B61UYuWwm0jdorCx4j/wCgnpf/AILZP/j9GPEf/QT0v/wWyf8Ax+q9n5k85u0VhY8R/wDQT0v/AMFsn/x+jHiP/oJ6X/4LZP8A4/R7PzDnN2isLHiP/oJ6X/4LZP8A4/RjxH/0E9L/APBbJ/8AH6PZ+Yc5u1yvjXSpNTuNDeOKWYWt3LMUSMOoItptrMCD/FtAPq2OpFXceI/+gnpf/gtk/wDj9GPEf/QT0v8A8Fsn/wAfo9n5hzlDwFHq502aXW5LpGUxww2ssKxJEixIcqoUH7xYenGO1Z2uafLL4vlkbT55717zTnsLtLZmEMCSgzL5oBCfKJcgkbg4HOa1L/SNR1Ty/wC030G88vOz7Ro7Sbc9cZmOM4H5VPbWuuWdulvaXmjwQxjCRxaU6qo9gJ8Cj2fmHOdFRWFjxH/0E9L/APBbJ/8AH6MeI/8AoJ6X/wCC2T/4/R7PzDnN2isLHiP/AKCel/8Agtk/+P0Y8R/9BPS//BbJ/wDH6PZ+Yc5u0VhY8R/9BPS//BbJ/wDH6MeI/wDoJ6X/AOC2T/4/R7PzDnN2isLHiP8A6Cel/wDgtk/+P0E+I1BIv9LkIHCfYJEz+PnHH5Gj2fmHObtFZukarJqH2iC7tvst3asFljDh1IIyGVuMqeeoByDxWlUNNOzKTuFFFFIYUUUUAFFFFABRRRQBz/j7/km3ib/sE3X/AKJaua+Nn/Il2n/YQT/0XJXS+Pv+SbeJv+wTdf8Aolq5r42f8iXaf9hBP/RcldOG/ix9TKr8DPRaKKK5jUK86+G//I6eOP8AsID/ANGTV6LXnXw3/wCR08cf9hAf+jJq6Kf8Ofy/Myl8cS9b/wDJLPEn/XbWv/Sq4rmv+bav8/8AP5XS2/8AySzxJ/121r/0quK5r/m2r/P/AD+VtR+Ff4kRPf5M9F8Jf8iXon/YPg/9FrWvWR4S/wCRL0T/ALB8H/ota165J/EzaOyCiiioKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8/1j/kvvhz/ALBN1/6EK9Arz/WP+S++HP8AsE3X/oQqoiZ0Fn/yUnWf+wTYf+jryuf+Hf8AyOnj7/sLL/6LFdBZ/wDJSdZ/7BNh/wCjryuf+Hf/ACOnj7/sLL/6LFPoxdUcZo3/ACQDxB/2EE/9Cgr1zwl/yJeif9g+D/0WteR6N/yQDxB/2EE/9CgrX8f/APJFvDP/AG6f+k7V6FWHtJcveT/JHNCXKr+R65RXnX/Ck/Dn/P7qn/f2P/43R/wpPw5/z+6p/wB/Y/8A43XJyUf5/wAP+Cb80/5fxPRaK86/4Un4c/5/dU/7+x//ABuj/hSfhz/n91T/AL+x/wDxujko/wA/4f8ABDmn/L+J6LRXnX/Ck/Dn/P7qn/f2P/43R/wpPw5/z+6p/wB/Y/8A43RyUf5/w/4Ic0/5fxPRaK86/wCFJ+HP+f3VP+/sf/xuj/hSfhz/AJ/dU/7+x/8Axujko/z/AIf8EOaf8v4notFedf8ACk/Dn/P7qn/f2P8A+N0f8KT8Of8AP7qn/f2P/wCN0clH+f8AD/ghzT/l/E6rVpvEKXUw0YaZ5IgXy/tQk3ebvGc7f4dmenOcdqoafqCad4Y1HUboO8drc380gTliqTynAyeuBxzWYtj4Y8F202lT6jqEaxW4uHzPMCImlChv3WBnfgZA3Y4PFQ3vhCx8V+F7mO6t1kvYbnUVspHkdFika4kwTtPIyq9QenStVGKXl3sZXbZ1um38WqaVa39urrFdQpMgcAMFYAgHGeeasB1ZmVWBZfvAHkVgeD/CNh4T0pI7W3SO8mhiF7IkrussiryRuPAyW6AdelMt9Fl0PXL3VbaN70XjHNtbRorqSd24vJJ0HTC7RznBPNZStfQtXtqdEZEEmwuofG7bnnHrSeYvmmPncBu+6cfn0/CuYuPC8+p+IoNceaO2dCWW1ntVdhmB4trskmGGX3c5PGARS6P4dk8Jxq1t9o1UCPyVVEjWTBYvudmdQ3JxxjjaMcZqRnUZpDIgk2F1D43bc849a57T9Jn03UtQ1wQzTS34UvYLHGrxYOBtbzNo45b5juPIx0qrL4audW8RRa5Kws2iZtlrc2yOxHkPFhmjkwy5k3c5PGMgUAdJcX9vaOqXDlS5AX5GO4nPAwOvB4p0N5b3GfJmViHKEZ5DAZIx6j0rk7f4fC2s0tl1RnSNSqu8ALsDuOWIYZOXPOBwAO2aIvh8kWsJem8idVnjmEZt2BUqyvkFZANxK8kg5AUY+U5NQ0OzoorjdE0HTta1HW73V0luJY9SeFGMrfKoIAHB6DP4AVhVquEoxirt/L/McY3OyorAgg8JQQiWKZFQ7QCZX5yMjj3FaMeo6Fa3MkC3cSPC6o+XOFZs4GemflNWpy6ofKXqKzri/wBEubeW4u3ZI42jWR3DKF8wgLk9Mcjnt3qhcaL4TuLQXUy5hdlUSec4UllDjnOOQR+eOvFS6k+i/H/gD5ToKK4i58Oad4a+IPhxtGSW3F59pjnXzmYSKsW4A5Prg/gPSu3p0qjnfmVmnb8E/wBSZKwUUUVsSUNPJ/4TDUhnj7DaHH/bS4/wrbrD0/8A5HHU/wDrwtP/AEZcVuVFT4vu/IuGwUUUVmWFFFFABRRRQAUUUUAc/wCPv+SbeJv+wTdf+iWrmvjZ/wAiXaf9hBP/AEXJXS+Pv+SbeJv+wTdf+iWrmvjZ/wAiXaf9hBP/AEXJXThv4sfUyq/Az0WiiiuY1CvOvhv/AMjp44/7CA/9GTV6LXnXw3/5HTxx/wBhAf8Aoyauin/Dn8vzMpfHEvW//JLPEn/XbWv/AEquK5r/AJtq/wA/8/ldLb/8ks8Sf9dta/8ASq4rmv8Am2r/AD/z+VtR+Ff4kRPf5M9F8Jf8iXon/YPg/wDRa1r1keEv+RL0T/sHwf8Aota165J/EzaOyCiiioKCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8/wBY/wCS++HP+wTdf+hCvQK8/wBY/wCS++HP+wTdf+hCqiJnQWf/ACUnWf8AsE2H/o68rn/h3/yOnj7/ALCy/wDosV0Fn/yUnWf+wTYf+jryuf8Ah3/yOnj7/sLL/wCixT6MXVHGaN/yQDxB/wBhBP8A0KCjxf4p0bVPhhoWk2F55t9afZ/Oi8p12bYWVuSADgkDg11HwdtLa+8A31te28VzA+oNuimQOrYSMjIPB5ANV/i9oek6Z4RtZtN0uytJWvkQvBbpGxXy5DjIHTgflXpqcfb8j3vf8DkcX7PmXY6X/hafg7/oMf8AkrN/8RR/wtPwd/0GP/JWb/4itf8A4RLw5/0ANL/8Ao/8KP8AhEvDn/QA0v8A8Ao/8K4b0Oz/AA/yOn955GR/wtPwd/0GP/JWb/4ij/hafg7/AKDH/krN/wDEVr/8Il4c/wCgBpf/AIBR/wCFH/CJeHP+gBpf/gFH/hReh2f4f5B+88jI/wCFp+Dv+gx/5Kzf/EUf8LT8Hf8AQY/8lZv/AIitf/hEvDn/AEANL/8AAKP/AAo/4RLw5/0ANL/8Ao/8KL0Oz/D/ACD955GR/wALT8Hf9Bj/AMlZv/iKP+Fp+Dv+gx/5Kzf/ABFa/wDwiXhz/oAaX/4BR/4Uf8Il4c/6AGl/+AUf+FF6HZ/h/kH7zyMj/hafg7/oMf8AkrN/8RR/wtPwd/0GP/JWb/4itf8A4RLw5/0ANL/8Ao/8KP8AhEvDn/QA0v8A8Ao/8KL0Oz/D/IP3nkcTqeo6Zr1/PqOleMZ7eGRF2Q/20bNQ4wpAjaIlVwCd3OT25zT18W6b4R8C7pNQ864lkvzYPMGm+1Okz4LMowckrk5Gc1p6pDr+nahPa+GPDzx6eEURNZ3VrAhY4ZnCNGSG6rzxjnGean0S0OseC7uz1GJ7Vr2W+injRwzRb55QwDYwSMnnGOK3vHlXbTqrmCT5n3HeD/F9j4s0pJLadJL2GGI3saRuqxSMDkDcORlW6E9OtWW8T6dFefZZpG83zxD+7idlUlxGu47cDLkL9T6c1oabYx6XpVpYW7O0VrCkKFyCxVVCjOMc4FVjoGmNM8ptvnkkWVj5jcssgkB6/wB8A/p04rCVr+6arbUqJ4x0V/OJuJUEMDXDb7eRcxLuy4yOR8jfXH0rR0/UY9RN15ccifZrhrdt643FcZI9uaxk8B6K1ibe7juLgvGY5JDdSqXQ7spw/CfO3yjjnpWl/Z13bXcsmlXFtbxXEnmzJNBJKzOcAkHzAFBAHAGM5Pep1GWdP1GDVLX7RaeYYtxUM8bJux3AIGR71aqG1tYbK1S3tU2RRjCrknH4mpqYgooooAK53wpbQ3sHiW1uk8yGfUriORMkblYYI49jXRVheCf9br//AGFpv6Vx1/41P5/kaQ2ZrDw5pSxiNbQKozja7AjlDwQeOYk/75qB9F0MXUkMkCq8xWRkMjAPyxxjOCMsxK9CTkitqud8Rpi8ifPWPGPTB/8Ar1z47ESw1H2sVe1jSKu7G7cW0V1GqXCb1WRJAM4wysGU/gQDVKbQNOnYtJFIMqF+SeRRwMDgMMHAxnqRx0qPQbye6SZJ33+Xt2k9ec/4VrVth68cRSVWOzE1Z2OR8TDHjzwiB033f/omuirnfE//ACPvhH/fu/8A0TW9cSmG2llWJ5mRCwjjxufAzgZ4ya1ofFP1/RGc+hJRVDSNXttbsjeWBZ7YttjlI+WUYGSvsCSvOOVP1rhf+Fj3v/Cb+V/Yev8A2D+zt39n/wBnr5/meZjzcZzsx8uc4z2rrjBy2M20tzudP/5HHU/+vC0/9GXFbleeeI9K0fU/F039s2c9y0dlbeUYre4lCgyzbwfK6EgYBPfnBwRSL4/8O+CbeHRRY6gI4w0kax2xTarOxAIlcPn3PXqMAgU5UnPWOr/4ARqJaPY9Eorzr/hdnhz/AJ8tU/79R/8Axyj/AIXZ4c/58tU/79R//HKn6tW/lL9rDuei0V51/wALs8Of8+Wqf9+o/wD45R/wuzw5/wA+Wqf9+o//AI5R9Wrfyh7WHc9Forzr/hdnhz/ny1T/AL9R/wDxyj/hdnhz/ny1T/v1H/8AHKPq1b+UPaw7notFedf8Ls8Of8+Wqf8AfqP/AOOUf8Ls8Of8+Wqf9+o//jlH1at/KHtYdzpfH3/JNvE3/YJuv/RLVzXxs/5Eu0/7CCf+i5KyPFvxe0DU/BOt2EFpqSy3Wn3EKF4owoZo2Azh+nNZfxD+Iek+LfD0FhptvexSx3SzEzogXaEcdmPPzCt6FCpGpFtGVSpBxdme4UUUVwHSFedfDf8A5HTxx/2EB/6Mmr0WvOvhv/yOnjj/ALCA/wDRk1dFP+HP5fmZS+OJet/+SWeJP+u2tf8ApVcVzX/NtX+f+fyult/+SWeJP+u2tf8ApVcVzX/NtX+f+fytqPwr/EiJ7/JnovhL/kS9E/7B8H/ota16yPCX/Il6J/2D4P8A0Wta9ck/iZtHZBRRRUFBRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/yX3w5/2Cbr/0IV6BXn+sf8l98Of9gm6/9CFVETOH0j4qa7N8fdT0kaTBeQyTS6cYrRQszR2zXDRlTJKqbsuSxJwQOAD16DwHrV/B4u8bPF4Y1W4aXVFZ44pbUNCdg+Vt04BP+6WHvXcWf/JSdZ/7BNh/6OvK5/4d/wDI6ePv+wsv/osVTatsQkzD+EOtX9p4Rukg8M6peqb5yZIJbUKD5cfHzzKc/hjnrT/izq17f+E7aK68P6lpiC9RhNdSWzKx2P8AKPKlc55z0xweemdT4J/8iXd/9hB//RcdHxs/5Eu0/wCwgn/ouSuz/mL+Zl/y5Ol/4SPVP+hL1z/v9Y//ACTR/wAJHqn/AEJeuf8Af6x/+Sa6CiuC50HP/wDCR6p/0Jeuf9/rH/5Jo/4SPVP+hL1z/v8AWP8A8k10FFFwOf8A+Ej1T/oS9c/7/WP/AMk0f8JHqn/Ql65/3+sf/kmugoouBz//AAkeqf8AQl65/wB/rH/5Jo/4SPVP+hL1z/v9Y/8AyTXQUUXA5/8A4SPVP+hL1z/v9Y//ACTR/wAJHqn/AEJeuf8Af6x/+Sa6Cii4HCat4/8AEOn3ohtvhzr12mwNvWWDg+nyuw/I96ueGdSY+DJNUvLV7JzNeXEtvNy0J8+RijbQeR0OAenFdfXP+H/+Qdcf9hC9/wDSqWtIfCyJbo5YfEd/7NluGtLNXimlj+a8+WXZAkwVCFOWYSbQOuRn/Zrqdc1Y6TaQygQr50wi825k8uKLIJ3O2DgcYHqzKO9X3toZLiKd0BkhBEbf3c9f5VBFpkEN410kl0ZGJJV7uV059ELFR+A47UxHK6Z4xvJvEFvbXMcbWt07KJVbEcJ3HaN2ASWwFXIAJ64JAPbUUUAFFFFMQUUUUAFYXgn/AFuv/wDYWm/pW7WF4J/1uv8A/YWm/pXHX/jU/n+RpDZlnxf4pi8MaYHAWS8nBFvEwO1sEbiSOw3D61zXw4vbjXL/AFe41aQ3cjCL/W8hRl+AOgHJ4HrT/idp13quoaHaWELTTP5+FXsP3fJPYe9bfhXwbD4f0uSKeQy3VwQZpEYheOigegyeSMnP0x5M1iK2OateEPu1X56m2iiaEEdrpl83lTExuuGU5O09ufzrVSRZVDRsGU9wayZNJmVv3bKy56k4q3aaasGHkO6QdMEgCt8L7am3TVO0fyE7PU57xP8A8j74R/37v/0TXQOpeNlVihIIDLjK+4zxXP8Aif8A5H3wj/v3f/omuir0qHxT9f0RjPoVdOsINL06GytF2wwrtXPU+pPuTkn3NN/smy/tz+1/J/0/7P8AZfN3t/qt27bjOOvOcZq5RXTsQcrqdvr1x4vul8PnTwFsrVpvtjyqeJZyu0x9uDkHgjjpmun0WG/g0mJNXMBvNztL9nd2jyXJG0v82MEcdB0HAFUtP/5HHU/+vC0/9GXFblKrJ/D6fkOEV8QUUUViahRRRQAUUUUAFFFFAHP+Pv8Akm3ib/sE3X/olq6Cuf8AH3/JNvE3/YJuv/RLV0FPoLqFFFFIYV518N/+R08cf9hAf+jJq9Frzr4b/wDI6eOP+wgP/Rk1dFP+HP5fmZS+OJet/wDklniT/rtrX/pVcVzX/NtX+f8An8rpbf8A5JZ4k/67a1/6VXFc1/zbV/n/AJ/K2o/Cv8SInv8AJnovhL/kS9E/7B8H/ota16yPCX/Il6J/2D4P/Ra1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV8r6t4D8Wp8eybOzjt7m81aXUrKWSWNlES3G7zSA3QcHb949MV9UV5/rH/JffDn/YJuv/AEIVcHa5Elcx7bSviSfG+poniTRxeLp1mZZDYna0ZkudgAzwQRISe+4elY/gzTfH0vifxcuma9pUFxHqKi8eWzLLLJsHKjPAx2r1Cz/5KTrP/YJsP/R15XP/AA7/AOR08ff9hZf/AEWKd9GK2qOL+F2m+PZ/C9w2g69pdrbi8YMk9mXYvsTJznpjH5UfFHTfHsHhe3bXte0u6tzeKFSCzKMH2Pg5z0xn866/4J/8iXd/9hB//RcdHxs/5Eu0/wCwgn/ouSuv/mKt5mX/AC5uS/2P8U/+hp0P/wAF7f40f2P8U/8AoadD/wDBe3+NegUVxcx0WPP/AOx/in/0NOh/+C9v8aP7H+Kf/Q06H/4L2/xr0CijmCx5/wD2P8U/+hp0P/wXt/jR/Y/xT/6GnQ//AAXt/jXoFFHMFjz/APsf4p/9DTof/gvb/Gj+x/in/wBDTof/AIL2/wAa9Aoo5gsef/2P8U/+hp0P/wAF7f40f2P8U/8AoadD/wDBe3+NegUUcwWPGfHXh34o3Wm2gu9SXWdMS4Rr+w0T/Q7mZOc7XPUdMr3/AJdJ8OoNVsvhnHFdxytfR+eEgllBlVwzAo8hBBbeGy2COa9CrndCkjQX9lvHn29/cNImeQJJWlU49CrirhqmRLdHJtJ4yitfs0hvftUs0xtdv2fdgQRlC5yRtEpfPOSO2OK6bUdSjvriDT9I1aAXQuQLlLeeMypGM7xtbPfAPGa3KKYjibH+3rPVLe88RzzRWNvM++eeaCOPDIQCyhjgBsAfMSS33VGa07yfUNSvoLrw/fLNYxtDu+zyRMjnzgJQScniItwD9OcV0dFABRRRTEFFFFABXOWWm69o9/qJ06TTpba8uWuB9o3h1LdRxx7fh26V0dFZVKUajTe6KTaKMU2tlg06adkDGUL5/Wr0Vxc/8txF/wAAz/WiimqaQczEnuLvJ+zLDjt5mf6VnTXHiTn7Omle28yf0rSopOmn1YczOW/svxHqPivStS1l9MS207zSqWpkLMXQr/EPpXU0UU6dNU726ibuFFFFaCM/T/8AkcdT/wCvC0/9GXFblYWkSR3PibVriBxJHHDb2rMpyA6GVyM+oEq1u1FT4vu/IuGwUUUVmWFFFFABRRRQAUUUUAc/4+/5Jt4m/wCwTdf+iWroK5/x9/yTbxN/2Cbr/wBEtXQU+guoUUUUhhXnXw3/AOR08cf9hAf+jJq9Frzr4b/8jp44/wCwgP8A0ZNXRT/hz+X5mUvjiXrf/klniT/rtrX/AKVXFc1/zbV/n/n8rpbf/klniT/rtrX/AKVXFc1/zbV/n/n8raj8K/xIie/yZ6L4S/5EvRP+wfB/6LWtesjwl/yJeif9g+D/ANFrWvXJP4mbR2QUUUVBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8l98Of9gm6/9CFegV5/rH/JffDn/YJuv/QhVREzoLP/AJKTrP8A2CbD/wBHXlc/8O/+R08ff9hZf/RYroLP/kpOs/8AYJsP/R15XP8Aw7/5HTx9/wBhZf8A0WKfRi6oi+Cf/Il3f/YQf/0XHR8bP+RLtP8AsIJ/6Lko+Cf/ACJd3/2EH/8ARcdHxs/5Eu0/7CCf+i5K7P8AmL+Zh/y4PRaKKK4DpCiiigAooooAKKKKACiiigAqhf6Jp+pTJNdW+Z0GEnjdo5FHoHUhgPbNX6KabWqFZPcx/wDhFtO/566n/wCDa6/+OUf8Itp3/PXU/wDwbXX/AMcrYoqvaT7i5Y9jH/4RbTv+eup/+Da6/wDjlYlzaWMOvvpiSzIypGym48QXUbSFywwq7jn7v612dV4rKOLULi8UsZLhERgTwAm7GP8Avo1Uaklu2JxXRHOadY6NqE5gjl1UyqCz7NTvCijcQPmLgZODx7Gqd3Fp0EdvIjXSx3NzLAklzr11EoCBssTvPUocexFdRpuj2+lPM1u8jGbG7eQcYLHjAH941FaaMsJg8xiRaXEssG09Q+7hgR23kfgD7VftNd2Ty6bHPWx0J7SOW7k1SJnEjfudUvJkKo5XeGD8qTjHHO4YrRh0jSLm0nmhk1bMBKyRyandoysFDYIMnoQfoRWnqOiWuqNIbrefMgMBAIwAWDZ5HUFR7e1RWfhvTrQMwgjknJbFw0Maum5dpClVAUY9B6560nUTV7sfL5HKWV3pMxtjctdstxAJALLXbu4eNiVARlDAgktgfQ+las0Hh23kZZrnV0CsU3/2hebS4G4oDv5bHYehHUEVvf2TANPs7PdJ5dmYzGcjJ2Yxnj25qpdeGLW7Z/NuLkRNM1wsKsoWOUgjePlznknBJGT06VXtE3u18xcrXQy7G00e9vJrdjq0LrcmCMPqd2C5ESSEkF+PvEe+M96BBoDwpJBLrMyyQrMDHf3hADruUE78Akdj7Z6itUeHUWQzDULz7S1wbgz/ALvdkxiMjGzGNqjtnPeltfDlvZxwxW11dJDHFFE8YZQJhGu1Sx25zgAHBAOOlLnXdhy+Rh2CaLd6fFcudXV5WwkEWpXkj/cDHgP2B+nTnJxU9rb+Hr6eOK1utWfzTtjkOo3gR22b8Bt+M7efoDWja+GILK3hS1vbuOWFiUnzGXwUCkcptxhV7dRUtn4ds7CO2S2abbaz+fGGYH5vKMWCccjaSfXPehzWtmwUX2RT0/QtNv7FJ9+pI2WR0/ta6Ox1Yqy58znDAj8Ktf8ACLad/wA9dT/8G11/8cq7pdmbHT0hkIMjO8shXoXdy7Y9tzHFW6zdSV9GUoq2xj/8Itp3/PXU/wDwbXX/AMcpP+EV0wgh21CRSMFZNTuWUj0IMmDWzRS9pPuPlj2IrW1t7K3S3s4I4IUGFjjUKo/AVLRRUFBRRRQAUUUUAFFFFABRRRQBz/j7/km3ib/sE3X/AKJaugrn/H3/ACTbxN/2Cbr/ANEtXQU+guoUUUUhhXnXw3/5HTxx/wBhAf8AoyavRa86+G//ACOnjj/sID/0ZNXRT/hz+X5mUvjiXrf/AJJZ4k/67a1/6VXFc1/zbV/n/n8rpbf/AJJZ4k/67a1/6VXFc1/zbV/n/n8raj8K/wASInv8mei+Ev8AkS9E/wCwfB/6LWtesjwl/wAiXon/AGD4P/Ra1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/AGCbr/0IV6BXn+sf8l98Of8AYJuv/QhVREzoLP8A5KTrP/YJsP8A0deVz/w7/wCR08ff9hZf/RYroLP/AJKTrP8A2CbD/wBHXlc/8O/+R08ff9hZf/RYp9GLqiL4J/8AIl3f/YQf/wBFx0fGz/kS7T/sIJ/6Lko+Cf8AyJd3/wBhB/8A0XHR8bP+RLtP+wgn/ouSuz/mL+Zh/wAuD0WiiiuA6QooooAKKKKACiiigAooooAKKKKACiiigAorjPGfiq70HUvJtb6xtyunS3cUFzGWe7lRgFiTDDls4wAWyRgViy+ONct7Ka5ur7Tbc/Z7i6tIpLYg3TRytGtunz5LHaM4BOZFwOMEA9Norz7VvHGoWH9qypNZi4tJJI49IaEtOqKoInYhx8uCXJO1SpA3A8mpdePtWh0A3iXNgFS8khFwxhJlRYVcYHnCIkMxBAkyQpxg5CgHplFeYal48v2n1S2aSEoLd3giiQq6ACMjfiQSxn5jnKBTlQG/vSS+N9ct59MF1c2EVtqhuS1y1uVWwSG4ji3MS+G3CQDJwA2DyOKAPS6KwvBusT674aS+upre4kN1dQia2QrHIsdxJGrKCTjKoD1PWucu/GGsp4l1XTbM2txNbxzPbW0UYdn8sI21v3gdGYbhkptO5MN/eAPQKK83ufiBfibT76Ga1TTNQkMlsvlhppYfNWNGCs6Fgy5YbNzDenynoc7w/wCO9aGsf2Vc3MNy8Wp/ZiJfLDyq9y6NjMof5FHAVGxtOcDlQD1mivM5PGPiSO1mu/tFgY0tLi8EX2Rs4huPL2bt/wDEpyTjgjiuj8O2QfxVrF9Bc332W1f7DFDNezSo74V5JNrsR1IQYAxsb+9QB1NFcv4wuIIr7SY9WvnsNJkeb7ROt01sPMEeY1MikED75xnqorT8LTXdz4P0afUzIb2Swge4Mi7WMhjUtkdjnORQBq0UUUAFFFFABRRRQAUUUUAFFFFABRRRQBz/AI+/5Jt4m/7BN1/6Jaugrn/H3/JNvE3/AGCbr/0S1dBT6C6hRRRSGFedfDf/AJHTxx/2EB/6Mmr0WvOvhv8A8jp44/7CA/8ARk1dFP8Ahz+X5mUvjiXrf/klniT/AK7a1/6VXFc1/wA21f5/5/K6W3/5JZ4k/wCu2tf+lVxXNf8ANtX+f+fytqPwr/EiJ7/JnovhL/kS9E/7B8H/AKLWtesjwl/yJeif9g+D/wBFrWvXJP4mbR2QUUUVBQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8AJffDn/YJuv8A0IV6BXn+sf8AJffDn/YJuv8A0IVURM6Cz/5KTrP/AGCbD/0deVz/AMO/+R08ff8AYWX/ANFiugs/+Sk6z/2CbD/0deVz/wAO/wDkdPH3/YWX/wBFin0YuqIvgn/yJd3/ANhB/wD0XHR8bP8AkS7T/sIJ/wCi5KPgn/yJd3/2EH/9Fx0fGz/kS7T/ALCCf+i5K7P+Yv5mH/Lg9FooorgOkKyb/W2t7/7BYWUl7dhVdwGCRxKScF3PToeACfatasHTju1vXicZF6ig47fZoTj8yfzrSCTbuRJtbDv7Q8Q/9AnTP/BnJ/8AGKP7Q8Q/9AnTP/BnJ/8AGK0KKv3e35k3fcz/AO0PEP8A0CdM/wDBnJ/8Yo/tDxD/ANAnTP8AwZyf/GK0KKPd7fmF33M/+0PEP/QJ0z/wZyf/ABij+0PEP/QJ0z/wZyf/ABitCij3e35hd9zP/tDxD/0CdM/8Gcn/AMYo/tDxD/0CdM/8Gcn/AMYrQoo93t+YXfcz/wC0PEP/AECdM/8ABnJ/8Yo/tDxD/wBAnTP/AAZyf/GK0KKPd7fmF33MctrB1JdQOi6Z9qWEwiT+1JeEJDEY8jHUDmrH9oeIP+gTpn/gzk/+MVoUUe72/MLvuZ/9oeIP+gTpn/gzk/8AjFH9oeIP+gTpn/gyk/8AjFaFFHu9vzC77mf/AGh4g/6BOmf+DOT/AOMVWvzrWpW3kXOk2ITcGDQ6zPEykHIIZIQR+B9q2aKPd7fmF33OYXSL+OCKGHSooY4gQFh8R3keSWLFm2xjcxLEljkknk1oTya5cWD2cml2QiePyyyazOkmMY++IQwPvnNa9FHu9vzC77mXbT61Z2sNta6LpUUEKCOONdSkARQMAD9x0AqT+0PEH/QJ0z/wZyf/ABitCij3e35hd9zP/tDxD/0CdM/8Gcn/AMYqK6n128tmgm0uxVGxkw6xNE3BzwyQgj8DWrRR7vb8wu+5i2I1rT1dYNMtXDkE/aNduJ/yLxHH4Va/tDxD/wBAnTP/AAZyf/GK0KKPd7fmF33M/wDtDxD/ANAnTP8AwZyf/GKP7Q8Q/wDQJ0z/AMGcn/xitCij3e35hd9zP/tDxD/0CdM/8Gcn/wAYo/tDxD/0CdM/8Gcn/wAYrQoo93t+YXfcz/7Q8Q/9AnTP/BnJ/wDGKP7Q8Q/9AnTP/BnJ/wDGK0KKPd7fmF33M/8AtDxD/wBAnTP/AAZyf/GKP7Q8Q/8AQJ0z/wAGcn/xilTXNJlW4aPU7NxajNwVuEPk/wC9z8vQ9aR9f0eOzjvH1axW2kYqk5uUCOR1AbOCaPd7fmF5dw/tDxD/ANAnTP8AwZyf/GKG1TXYlLzaLaSIvVbbUC0h+geJQfxYVejkSWNZImV0cBlZTkMD0INVLbVrK71S9063m33Vjs+0R7GGzeNy8kYOR6Zp2j2/MV33L+m6jBqlmLm2Dqu5kZJEKsjKcFSD0IIq1XL6fqf2HWr62EIdbrVvJBDY2f6EkpPTnlT/AN9Vu6Vff2no1lf+X5X2q3jm8vdu27lDYz3xms5wcXfoXGSehlePv+SbeJv+wTdf+iWroK5/x9/yTbxN/wBgm6/9EtXQVHQrqFFFFIYV518N/wDkdPHH/YQH/oyavRa86+G//I6eOP8AsID/ANGTV0U/4c/l+ZlL44l63/5JZ4k/67a1/wClVxXNf821f5/5/K6W3/5JZ4k/67a1/wClVxXNf821f5/5/K2o/Cv8SInv8mei+Ev+RL0T/sHwf+i1rXrI8Jf8iXon/YPg/wDRa1r1yT+Jm0dkFFFFQUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/YJuv/QhXoFef6x/yX3w5/2Cbr/0IVURM6Cz/wCSk6z/ANgmw/8AR15XP/Dv/kdPH3/YWX/0WK6Cz/5KTrP/AGCbD/0deVz/AMO/+R08ff8AYWX/ANFin0YuqIvgn/yJd3/2EH/9Fx0fGz/kS7T/ALCCf+i5KPgn/wAiXd/9hB//AEXHR8bP+RLtP+wgn/ouSuz/AJi/mYf8uD0WiiiuA6QrA03/AJDWv/8AX+n/AKSwVleOtf1PRtR0+LTbnyUms76Rx5atlo4dyHkHoeffvUXhnXIItLu9R12/t7drma3Z5riRYleRrKBj1wMnk4FdMKclHm7/AOZhKacuXsdbRXO+EPGFj4s0mG4je3gvHV2ksVuFkkiVXK5I4ODwc4H3hVybxBbxa8NJWC4lmCo0jxhSIw5IUld28jI5YKQO5GDhSTi7Mad9Ua1FZ+s6zaaFYfa78sIt4X5FyfUnHoqhmPoqk0y4120tdYi0yVZftc20woE/1qnO5lPouMt6ZH95coDToqha6vbXmkPqUO/yE8zOVw3yMVbj6qaoP4u05gosllvpGSBlityhJ80sFGSwAPyNnJFAzeorC03xbYandxwQQ3Klp3tWd1XbHOgctESCfmARjkZXGOeRm1rGuRaO1sslvNcSXLMqJE0a9BkkmRlH60AadFc9/wAJhavqh0+CyupblXKSIGhXYRtzy0gz98fdz3qzZ+JLW9uoY0guI4bp3S1uXVfLuGUEkLgk9FYjcBkKSMikBsUVmajrcdhdC2S0ur2fyjO8dqis0cYONxBIzzwAMscHAODVO78Vx2V1eRT6XfKtnCs7y/utpRyyoRmTPJRhyBjHOKYG/RWNpviaz1K6+zJFNDcCVomjfY21lRX+8jMp+V1PBPvitmgQUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUVmaxrkWjtbLJbzXElyzKiRNGvQZJJkZR+tAGnRWA/jDT4pmhmiuUlEpt0QoD5kwCnylIJBbDg+mAxzhSQk/i62gnvE+xXUi2bFHkR4fmYY4CmQN1IGSoHvjmkMyJPC2tT2McMiafG1nDNHA63DkzF5FYBj5Y2LhOQN3OPTmxJ4W1O/1KS+nu10uWaZ5G+wSljH+5WNSGZAGPy5OVHAUc4yeh03VE1Hz08ia1nt3CTQThdyEgMOVJUggg5BI6jqCBQfxXam+uLOztLy9ubVmE8Vui5QKFO75mGQdwAAyTg4BwaALGnaS8HhKDSJW+yOlmLYvZSN+7+XbuRm5B7gnJB9a5HQfAF7Y+NdTvbjVtaFqkltJbTG+Ute7VyyzYGWAPygEDgmu6jv7SXTE1FLiP7G8InE7NtXyyN24k9BjnmsDTPHmkal4k1DSlu7JFt2hS2nF4jC8aRckIO5BwuATye1awcknykStdXGj/kaD/2Hf/cbWPpngXXNS0XTry18a6hYwzWcDJbRh9sY8teBiQD9BW5DO8XiSVU24k1zB3IGI/4lwPBI4PHUc4yOhNXNC8U6JF4b0tb3WdMt7j7FCZIjcRRbCY1ONmRt+mBiqlKcV7vl5kxUW9TifFvgDX7PwTrd1P451K6ig0+4keBxJtlURsSpzKeDjHQ9a1/+Fb+I/wDooWqflJ/8drS8beJdCu/h/wCIbe11rTp55tLuY44o7pGZ2MTAKADkknjFbn/CW+HP+g/pf/gbH/jU+1rf0l/kaclP+mcj/wAK38R/9FC1T8pP/jtH/Ct/Ef8A0ULVPyk/+O113/CW+HP+g/pf/gbH/jR/wlvhz/oP6X/4Gx/40va1/wCkv8g5Kf8ATOR/4Vv4j/6KFqn5Sf8Ax2uU8JeEtW1TxD4jtbPxTe6fLY3XlzTxB9102+Qbmw45+Unkn7xr1n/hLfDn/Qf0v/wNj/xrg/AGuaTZ+LvGM15qllbxXF8HheW4RVlXzJTlSTyOR09RW0KlVwk35dF39CJRhzL/ADKfh74da1qWhXSnxrfxwNfX0EkOx2V9t1KjEjzMHcQWI/2j161teKdC/wCEa+B91pP2j7T9n2fvdmzduuVbpk4+9jrWl4R8S6FbaLcJc61p0LnVNQkCyXSKSrXkzK2CehUgg9wQap/EjxFot98PtStrLWLC5nfytsUN0js2JUJwAcngE1EJ1ZTjGW110G4wUW1vY6jwl/yJeif9g+D/ANFrWvWR4S/5EvRP+wfB/wCi1rXrln8TNo7IKKKKgoKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArz/AFj/AJL74c/7BN1/6EK9Arz/AFj/AJL74c/7BN1/6EKqImdBZ/8AJSdZ/wCwTYf+jryuf+Hf/I6ePv8AsLL/AOixXQWf/JSdZ/7BNh/6OvK5/wCHf/I6ePv+wsv/AKLFPoxdURfBP/kS7v8A7CD/APouOj42f8iXaf8AYQT/ANFyVynw8+Iek+EvD09hqVveyyyXTTAwIhXaUQd2HPymj4h/EPSfFvh6Cw023vYpY7pZiZ0QLtCOOzHn5hXo+xqfWee2lzl54+ytfU9worzr/hdnhz/ny1T/AL9R/wDxyj/hdnhz/ny1T/v1H/8AHK4/q1b+U6Paw7ln4h6de32qaY9lZz3CpY6grGKMsFLW5Cg46Engep6UeFNItrvRZ7PWtPhn8mW2LQXcIbY4srcfdYcEZI9etV/7d0bx60d3bW1yotIriH/SLKWQ/PFhsGGTA47Ny3RcHmprDU08N6dftDpmoX6LeQQrDp9ozOo+xw4JRjuUfLjkkgkA1ulJQ5Huv8zDRzcv62NHwj4PsfCekwW8aW895GrpJfLbLHJKrOWwTycDgdT90VY1Dw3BqOqQ3txd3JEMscyW/wAhQOhBBBKl1zgZCsAccjk5wfhv4uvfEWjQRapaag90I5JH1CS1VLeXEmAqsuASAQMY/hb0rU1DXr2z8Rx24WBbDzIYWkMbPmSRsbS6sfKPzLgMmGyBuGeMqikpPm3NI2toS3Oivr9zCfEljbGC3V/Lhiu2lRmYBdzAxryF3Ac9Hbjpgi8JWkU1lO13ey3NikUdvPJIpeNEGCv3cEOM78jJ45G1dqeLfETeHdOikt4RcXM0hEcOCdyqpd+BzkhdoPTcy54qGfxSR4j07TrT7PNb6lGk0NyGOETDMQw9XC/J64f+582ZRZttLurK0bSbe3hfTXMgM73Z87EhLN8gi28FjjnpimP4L0eXYJIA8apAjRMiFJBCXK7ht5zvOfoOlTabrMt74Wk1R40WRBPhBnb+7d1H57RWHN41vHjUQ2b2rNFaNumtJJjmZpAxEaNuYDyxjHqaNANv/hG7a2vlvdP3RmFvNislKxwGURGIMcKWHyHbxxwDjNSHTX1S4gn1yztla1ZjFHFN5yNuXBLbo1/DFZGj+JtVu9Qghv7WGBGvGsmQxskjEQvMswBPyqyKvyEEgscn5cHraAMa18Mafa61cantaWedy+JQrKhO3leMj7g70yDw3HYyQy21xPOlmXksrOZ0WGB2Vl4KpuxhmUZLYDHjpW5RTAwpdHvNTuWu7qZ9JufKMBfTrkSGSMnOCXiGCDnBHIyeasXnh6zvjd+e0pF3bw28g3A/JGzsvUHkmQ5znPFatFAGB/wiVtDcCXTL2703bM8yR2wi2Rl1AcKrowAJG4j1JPc1vAYUAknjqe9LRQIKKKKACiiigAooooAKKq6it82nzDSZLeO82/umuY2ePPowVlPPTIPHXnofFl+NviXRvFI07xZpFjDFBN5d2kEbrIg/vKS5B9Rxhh0IzmtIU5T+EyqVY07cx7nRVewvrbU9Pt76xlEttcxrLFIARuVhkHB5H0PNWKzNdwooooAKpXulWuoXVrPdxiU2pYojKCpLDByCKu1z0viOSJhujgA/tGW0Yu+0BUgeQEk9PuDJ6YOaBhceDLC5uri4kuLvzJJjcRYdQLaY7f3sfy/eAQD5s8bhjDMC248GW0895INRvIheO0jqkcHyscchjEW6gHBJH4cViN4w11ZY7M28P29k814VsJGdBtYgbRLtYEqQJFcg4PAxzMfH041K122kMmnvbQXU8sbktHFJGzM6/wB4LgHoDt3d8CloGpvw6fe6UZXsNupT3T77ie/ufKbhQqgCOIrjA6AD15JJqBfCkSXtxf2t9eWF5eMzXD27RtuyF+X50PAK5BwDyeecVmWnizUrqxi1JRZ/ZBFZvJAEbfIZ9udj7sDG4YG056ZGcjodYvbi1Wzhs/KWe8uBAkkylkj+RnJIBBPCEAZHJFAFiHTrSDSo9Njt0NlHALdYGG5fLC7dpB6jHHNYWmeA9I03xJqGqrZ2TrcNC9tALNFFm0a4JQ9iThuAOR3rUstXNz4Vt9Za2kcy2S3Rt7cb3OU3bFHG49h61x+g+P72+8a6nZXGka0bR5LaO3hNioay3LhmmwcqCfmBJPANawUmnykStdXN2G3mm8SSvFEzrHrm5yoyEH9nAZPoMkDPqRUOlfDfw3e6Hp1xq2kMb17OHz980qMHEaggqGGDx0xTh/yNB/7Dv/uNroPCn/Im6L/14Qf+i1oqSlFJxdtggouWqOP8X/DvwtpfgjXNQsdL8q6tdOuJ4ZPtErbHWNmU4LEHBA4NbH/CrPB3/QH/APJqb/4ur3j7/km3ib/sE3X/AKJaugrL21W3xP7zT2cL7HI/8Ks8Hf8AQH/8mpv/AIuj/hVng7/oD/8Ak1N/8XXXUUvbVf5n94/Zw7HI/wDCrPB3/QH/APJqb/4uuL8E+C9A1fxR4qtNRsPOg0+88q2TzpF8td8oxkMCeFXrnpXsVedfDf8A5HTxx/2EB/6MmrenVqOnN8z6dfMzlCPNHQTwv8O/C2o6RPNeaX5ki6jfQBvtEowkd1LGg4bsqqM98c81sf8ACrPB3/QH/wDJqb/4ur3gr/kA3P8A2FtS/wDS6eugrF1qt/if3lqnC2xDaWsNjZQWlqnlwW8axRpknaqjAGTyeBU1FFYmgUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/YJuv/QhXoFef6x/yX3w5/2Cbr/0IVURM6Cz/wCSk6z/ANgmw/8AR15XP/Dv/kdPH3/YWX/0WK4fSNd+I7fH3U7dLOeexM0sJS7tvs8JtUa4NuWmWFiq5L7Wwd5GMnt0HgO58SL4u8bG00nSpZW1RTOsuqSIsbbBwpFu24e5C/SqcbIhO56xXnXxs/5Eu0/7CCf+i5K6X7Z4x/6AWh/+Dqb/AORa4b4s3GvS+E7ZdZ03TbSD7ahV7XUJJ2LbH4KtCgAxnnPYcc8aYZfvoiqv3Ges0Vz/ANs8Y/8AQC0P/wAHU3/yLR9s8Y/9ALQ//B1N/wDItYWNLkuv6dqd7c276Y8CokM6yebPNGdzJiPAjIBG7qTyByuDVLw3DNby6rDdlTPHdRLKUZmUsLSDOC3zEZ7nn1qjrOqfEmB4v7G8M6FMCD5m7VXbHpyYk9+x+tS+DJ9YuY9Xl8SWlvZam1+POgtpfMjT9xCFw3fK4P1NbQk2nH+tzOUVe5s6TpNloemRafpcPkWsOfLj3s2MsWPLEnqTRLpOnT6hHfT2FrJeRgBLh4VMiYzjDEZHU/ma43RZfEzavpNrei/+zQXkss8siMPOjkilMascdEcMMdv3XqK3PFza1Na29l4dSQXMrNK04bYsYQZUFunMhjyv8S7/AHovfVhaxp2mmNb3Yubi+nvZVQxo1xHCDGCQWAKIp52rkZxwPSnx6Tp0UPlRWFqke5G2LCoGUxsOMdV2jHpgY6Vyltf61eao919m1O30y4t3e3hljYSRXXlAlWGMiMfMFzxvDdjHWvI+rf8ACv4Wg87+0/sURkyv70NtXfgH+PG7AP8AFikBfXSBHMfJvJorQkk2KRQiE5+8P9Xu5JJPzdSas/YLTer/AGWHcgUK3ljKhc7QPpuOPTJ9a4YLqt9qy2umWmpnT1kLB7vULy3DfIertGJBjCnbllJbggg1pWSazbeIbG2vbi9upImjjlnEbCCWAWrbnOPkDmcf7wG0dKAOnNhZtfrfNaQG7VdguDGPMC88buuOTx7mrFct4qu9cj1C2bRLW4lhsE+2XIj488bseUvHzkoJflHRjGfSq00t59uvjL/bP9oedKLdbdJPs/k+WSmcjy/Qn+Pfx04oA7KiuM1DUNdv9N00+Hku1mETrdfaLeSFuEUnb5igbzyFLfKGOTnBB6uxdJNOt3iEyo0SlRcBhIBj+IN8271zznrQBYooopiCiiigCtf2FtqljJZ3qGSCTG5Q5XOCCOQQeoFcNrfhbSpNTttH0Kyf7RK266uVu5W+xx8HJBYjLDOAfSu01nUW0rR7i9jtpbt4lG2GFcs5JAH4ZPPtmue8P6lp+l2kkl7Ld3GpXTeZd3I064+duwGU+6o4A/QZpMaJpok8JavaTwMy6RdhLSaIkkQy9ElJOeCAFPTsTk1EWbxBfX2rqxOnafBLDYMjfLM5UiST3A+6Oo4JrX8QKuoeDdR8qJpRNYyNGjRncTsJX5SMg5xxjOabZW3keCYreOHy2FgB5apjDFOePXOfxoAy/CWo3Nmtrouoq7K1qk9ndyH/AFylQTH/ALy5I91GcCqFteXZOp6ZY3DW91qGuzQpOMEwosau5APfAIH1z2rdOkvqHhHT4VJhvbaCKW2duPKmVPlzx0zwRjoTXO2FtqSWtxrMmnSf2hY6u8z20cZ/eq0SRy+WO4+8VOecUhmxceBdMtbd7jQImsNTjBa3uVldiG64IZiGB6HOeCas2kFhrvh6x1TVNMtb67e1TcZLZXYtjlRkHA3E/Squt+LJY7BJPDkRvro5D2htpTIoxgEgD5MHBww5GcVc8MXdrDoelaf5ubk2isVwT8wHz5OOCGzkHmmnZ6CautSlZ6ZKk/lWloLCKRyxWKHy0X3wAB0FdRDEsMSxpnC+pyafRVN3JSsFFFFIYVT/ALJ07+0W1D+z7X7aww1z5K+YRjH3sZ6cfSuf8Rz65beI4JdJW5kge1NuyKhaNZJGISQj/ZYJk9lZjVq2uNVsvh1aSJFcXOriwhRVmUl2nZVUGTuPmOWJ6AEnpSGXP+EV8PeT5P8AYWmeUG3BPsce3OMZxjrjirqadZRzieOzt1lChBIsShgoGAM46AHGK42SXxPH4fjsrOK9/tmzuZI0lkO+OaDbuDO5G1m2Oqg95V5+XfW7ocl1Jq17vF4LH7Lam2+1I6nJV92d3O77u7POetAF1PD+jRXEE8Wk2KTW6KkMi2yBolUYUKccADgAdKRdHWWKSHVLuXVYHxmG8hhZAQcg4WNecjvXLapcatDqF0Ug1SW+N0yxCB5lhWAgBSoCNE3BJbcVbIIB+6KfbWOtWWm28uoyXi2k7wC5t7a6uLmaMBJCzhyBINzmIFVGFCk9zQB20caRRrHEqoiAKqqMBQOgAqrbaTZWmqXuo28Oy6v/AC/tEm9jv2LtXgnAwPTFVtPbVG8IWrPs/tc2KE/agQvn+WPvhecbuuPfFcL4ZHi7/hZPiDzP7F8zzLP+0sebt2bOPJ99uc7uM47VpGN03chuzR11pZNdeILyZZFUWusCVw2clTYInHvlx+Ga2vDSLH4T0hEkWVVsYQJEB2uNg5GQDg+4BrDtVY+ILwqrELrAJKwhwB9gTkk/cH+0OckL0Y1mzat8Q43VdD0PTLrTxGn2edrrzfMXaMHe0oLf7xAJ605Rc9L9twi0nex0Pj7/AJJt4m/7BN1/6JaugrybxPqvxGm8I6xFrGgadb6e9jMt1NHIC0cRjO9h+9PIXJ6H6Gn6344+IXhyyS71nQ9LtoHkESvnfliCcYWUnoDUrDyeia+8r2qWrT+49WooormNgrzr4b/8jp44/wCwgP8A0ZNXotedfDf/AJHTxx/2EB/6Mmrop/w5/L8zKXxxOl8Ff8gG5/7C2pf+l09dBXP+Cv8AkA3P/YW1L/0unroKwe5otgooopDCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP8AWP8Akvvhz/sE3X/oQr0CvP8AWP8Akvvhz/sE3X/oQqoiZ0Fn/wAlJ1n/ALBNh/6OvK5/4d/8jp4+/wCwsv8A6LFcPpHwr12H4+6nqw1aCzhjml1Ey2jBpljuWuFjCiSJk3ZQhgRgA8Enp0HgPRb+fxd42SLxPqtu0WqKryRRWpaY7B8zboCAf90KPaqaVtyE2esV518bP+RLtP8AsIJ/6Lkrpf8AhHNU/wCh01z/AL82P/yNXDfFnSb2w8J20t14g1LU0N6iiG6jtlVTsf5h5USHPGOuOTx0xphv40RVfgZ6zRXP/wDCOap/0Omuf9+bH/5Go/4RzVP+h01z/vzY/wDyNWFjQ6CsDTf+Q1r/AP1/p/6SwVkaz4F17U3iNr8Q9dsxGCG2xW43Z/3I0HH0zz1qXwZpl1o0er2F/qlxq1xFfjfe3IAklzBCRnHHAIH0FaU+v9dUTPobKXmnam1zZR3FrdmPMdzArq+3OQVde3cYNJaWmmaZJ9msbe0s3mBfyoUWMyBcAnA643DntketYOlaXfaHqEt5fLEtlHFIixW3mXLFnkU7kXy98anBJQM45HQLktm0i+1jxFHr9ndeULWaJLe3nt3jzEARLu3qGBYSvgAYOyM544ZJ0pv7QRhzdQBCpcMZBgqCAT9ASAT7ioU0zSrO8+2R2VnBcyMR56xKruzdfmxkk/rXLy+DtSe31vElnv1iJiybmC20m8kKh28owYsxwDv3Nj58LraiqeJYre3s2u7YwXMc7vLbTW52qedrMgyfagDTn1nTLWWOO61G0hklYrGkk6qXIOCACeSDx9akWay1GO4gSSC6RSYZ4wyuAehRh/MGuXg8ETOZYL7UJfsU0dzFMkbgtcJLO8m1yyZHytglSDnPPerOjWE/hvfNqYDoLaCyjNnFLO8giMp8xwqZUt5nPUA55OaANu0tNM0yT7NY29pZvMC/lQosZkC4BOB1xuHPbI9adb6pp92XFpfW05R/Lby5lba/904PB4PFcxq/hvUfEGpNq1pqH2TASK1jeJkZYirLKzblDK5EsmBjGUiJ9pf7G1s29lix0eOWx+zrGI53HmrHuBBfy/lUZ4XaeSeaAOoe6gjJEk8aEMqEM4GGY4UfU549alrlm8O6i/idNeaSATBos2bSl4lXZtkYHYD5gB+VsdAV+UOxrqaYBRRRQIKKKKACiiigAooooAKKKKACiiigAooooAKKKKACsy+tdDspjqupQafbyqwJvLhEVgeg+c9+gHNadZeu6XLq1tbQwzGDy7qOZnVtrBVOTg4PNAyddZ0t2t1TUrRmuhm3AnUmYdPl5+b8KbeWek6mkL6hbWd4uSsTTxpIMnqFz647elZb6LqEGqXL20dne2939n8yS/dmePyvRQuH6bh8y4Yk1Tfw1qt94fg0e9eGziguA4ubK7fzWTLZxmMbGwR0J78jANIDqrd4HgX7K0bRLlB5ZBUbTgjj0IxjtiobfVNPuy4tL62nKP5beXMrbX/unB4PB4rJtiY9FHh+78yC68g2omsrKUQqNuFdWCBF+XBxnCnIycZqn/Y2tm3ssWOjxy2P2dYxHO481Y9wIL+X8qjPC7TyTzQB1D3UEZIknjQhlQhnAwzHCj6nPHrSWt3bX0AnsriK4iJIEkTh1JHXkVyOq+EdT1TULnURcwwTzxCEW5kLxRhojHI6naD5gzlWx0BX5Q7Gt7QbC6slvZb6O3ilu7hZfKtnLpGBDHHgEquf9Xnp3xQA/RbeGbVNbeWNXaPUlZCwyUP2SEZHocEj6E1s2lv9ksoLbzZZvJjWPzJm3O+BjLHuT3Nee3ng/WPEHibWrrS/GeqaFEl0kZtrNEKOwt4jvO7uQQP+Aiuis/Cur21lDDL431yR40Cs/k2fzH1+aBj+ZNKpvb0Kjtcm8ff8k28Tf9gm6/8ARLVzXxs/5Eu0/wCwgn/ouSt3UPBt5qmm3On33jDXJbW6heCaPyrJd6MCrDItwRkE8isL42f8iXaf9hBP/RclaYf+LH1Jq/Az0WiiiuY1CvOvhv8A8jp44/7CA/8ARk1ei1518N/+R08cf9hAf+jJq6Kf8Ofy/Myl8cTpfBX/ACAbn/sLal/6XT10Fc/4K/5ANz/2FtS/9Lp66CsHuaLYKKKKQwooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigArz/WP+S++HP+wTdf8AoQr0CvP9Y/5L74c/7BN1/wChCqiJnQWf/JSdZ/7BNh/6OvK5/wCHf/I6ePv+wsv/AKLFdBZ/8lJ1n/sE2H/o68rn/h3/AMjp4+/7Cy/+ixT6MXVHoFedfGz/AJEu0/7CCf8AouSvRa86+Nn/ACJdp/2EE/8ARcla4b+NEir8DPRaKKK5zUKwNN/5DWv/APX+n/pLBW/WBpv/ACGtf/6/0/8ASWCtafX+uqIn0NOiiiqICiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAjnmW3t5JpM7I0Ltj0AzWJb+LIrq3gkh028aS5OLeBXgZ5QF3FsiQqoAIzuI6gdSK27iFbm2lgckLKhRiOuCMVlv4atFt7JLGWWwlsgRFPbLGGIKhWBDKVOQBnjqBSGTQa3bXFvcyiOeP7LEssqSxlGUFd2MHnOO1O0vWbXWUklsN8kCEL52PkZv4lU9yp4PYHIzkECnH4YWKSUrquoFLiERTxu0b+bhCu4sULZ5zwQM9scUlro0mgZTw7bQtBIqB7ea58mONlUKGULG3LADPQfKCBkkkAZJ4wsYdSezlguF2yvCJcxlWdIzIQFD7/ALqnkqBx1oXxfa/2OdSls7iKLfGkatLATIXOF5EhVev8RWlfwjp805u2DwXkkkkkk0JXcRIu14yxXlOhwR1VT2otvCiWmlmyi1S9CfJtcRwKVCgjBCxBXBBwQ4b2weaNQHW3iqG61JLKOwvFkIXzDIYk8otnghnDN06qGB6gmkTxSrTTwtpOoJNDcC2EZMJMkpQSbVxIf4G3ZOBgHnPFV9M8EWekXaT2V7dJtYMyGKAqxDFj/wAssqCWPCFQB0ArQn8PwTSTzR3FxBPLdreLNGV3RSCJYvlDKRgouCCD94+2DUCS416zt/Df9ufvZbMwLcL5cZZ2RgCML1J5HHWpdP1W01UTNYyebHEyr5g+6+6NZAVPcFXXmqEWlXB01NFltoYtMhjWGOWO7Z5SqY2ZUxgZO0Z5P41a0jQ7TRHvzY+YFvro3Txs2VRiqqQvovy5x6k44wAAc1H8RvDfh3xtqeh6xeNb3F3fRskxiYwrugiRQ0n3VJZGHPpzivQIZ4rmFZreVJYnGVdGDKw9iK8vu/hZpvi7xbq1zqeoXq6Yl/EbjSImAgunWFJAz9/vStnB546V2EPw88GwQJEnhXRmWNQqmSxjc4HTlgSamfxFx2Ojrzr42f8AIl2n/YQT/wBFyV0v/CA+Dv8AoU9D/wDBbD/8TXDfFnwxoOi+E7a40bRNN0+dr1I2ltbSOJipRztJUA4yAcewrTDW9tEirfkZ6zRXP/8ACA+Dv+hT0P8A8FsP/wATR/wgPg7/AKFPQ/8AwWw//E1hoaanQV518N/+R08cf9hAf+jJq6X/AIQHwd/0Keh/+C2H/wCJrhvAfhjQdR8WeL7fUNE027gs70R20U9pG6wLvlG1ARhRhQMD0HpW9O3s5/L8zOV+eJ3Pgr/kA3P/AGFtS/8AS6eugqvY2FnpdlHZ6ZaQWdrHnZBbxiNEySThRgDJJP41YrB7mi2CiiikMKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8/1j/kvvhz/sE3X/oQr0CvP9Y/5L74c/7BN1/6EKqImdBZ/wDJSdZ/7BNh/wCjryuf+Hf/ACOnj7/sLL/6LFdBZ/8AJSdZ/wCwTYf+jryuf+Hf/I6ePv8AsLL/AOixT6MXVHoFedfGz/kS7T/sIJ/6Lkr0WvOvjZ/yJdp/2EE/9FyVrhv40SKvwM9FooornNQrnroXek61dXKWUt1Y3pSR2twGeKQKEJKdWUqqcjJ4PFdDRVRlysTVzn/+EgtP+fbVP/BTdf8Axuj/AISC0/59tU/8FN1/8broKKvnj2I5X3Of/wCEgtP+fbVP/BTdf/G6P+EgtP8An21T/wAFN1/8broKKOePYOV9zn/+EgtP+fbVP/BTdf8Axuj/AISC0/59tU/8FN1/8broKKOePYOV9zn/APhILT/n21T/AMFN1/8AG6P+EgtP+fbVP/BTdf8Axuugoo549g5X3Of/AOEgtP8An21T/wAFN1/8bo/4SC0/59tU/wDBTdf/ABuugrk5bzS9Q8WNb/2qLb7PJski/tBke4mIwEVN33RnnA5bA7HNxal0E011Ln/CQWn/AD7ap/4Kbr/43R/wkFp/z7ap/wCCm6/+N1nXH286FrLXF/MW0+N7OF4pCrNwreYxH8eCoz2wSPvYDLrUL+O+axv55oxbJEt1OjFA8Jk/1wI+7kcMRjb83QAGr5U/6/4BOpqf8JBaf8+2qf8Agpuv/jdH/CQWn/Ptqn/gpuv/AI3WdHqFiRq4025nu7C1gR1SO6kBE+5xsV87sHC9Dt5BHWr2qWtzp/hmytEuJp5/tUCPI1y6GQtINw38sAckd8DilaN7D1tcf/wkFp/z7ap/4Kbr/wCN0f8ACQWn/Ptqn/gpuv8A43VZ21jRwsaMjG4mkkSAyvclUSLOxXbByzKfYbuKbH4jumhO28s5oyLcveomI7cyFtyt83UbRjnjeM+5ZdP6/AC3/wAJBaf8+2qf+Cm6/wDjdH/CQWn/AD7ap/4Kbr/43WfL4pvUvBFDJbSgeWEfZtW4DMQXUF92BjjarD5Tzg5EP/CW3v8AZ3m+fa71kw7gJg/u9wCnzNrc5OCytjtnmnyPt+P/AABXRrf8JBaf8+2qf+Cm6/8AjdH/AAkFp/z7ap/4Kbr/AON1DBql7c3Cw2kiQ/aLyRN8sbMVURBx8pYYOe36VW0bxTd6nPpJmltYmvpNslkEPmIn2dpA+d3QkDt0I98rl0vb+vuGX/8AhILT/n21T/wU3X/xuj/hILT/AJ9tU/8ABTdf/G6oeJblbfVJpHvPmjt1Mdt9qe3lBy3zQ9VkY8DaR1ABODipJ/EOorFcAeRE1nIILh5BtDOXONpYhQdgVvmIH7wc9qOW6TSF1Lf/AAkFp/z7ap/4Kbr/AON0f8JBaf8APtqn/gpuv/jdZX/CSXqNJcidWWaG1IVkVREGZ1aQAvjGRjO7GSOSOs8viLVDp63ELWylLaWdsx7hJsl2DGGwARzwT7Einy+X4/8AAC5e/wCEgtP+fbVP/BTdf/G6P+EgtP8An21T/wAFN1/8brQ0m6uLgXcd2yPJbXJiDom0MNqsDjJ/vY/CtCsnJJ2t/X3FqLZz/wDwkFp/z7ap/wCCm6/+N0f8JBaf8+2qf+Cm6/8AjddBRS549g5X3Of/AOEgtP8An21T/wAFN1/8bo/4SC0/59tU/wDBTdf/ABuugoo549g5X3Of/wCEgtP+fbVP/BTdf/G6P+EgtP8An21T/wAFN1/8broKKOePYOV9zn/+EgtP+fbVP/BTdf8AxukOvRMpFtYapPL/AAx/2fNHu/4FIqqPxIroaKOddg5X3MvQrS5tre4mv0SO5vLhp3jRtwQYVFXOOSFRc++a1KKKzbu7lpWVgrzr42f8iXaf9hBP/Rclei1518bP+RLtP+wgn/ouSt8N/GiZ1fgZ6LRRRXOahXnXw3/5HTxx/wBhAf8AoyavRa86+G//ACOnjj/sID/0ZNXRT/hz+X5mUvjiei0UUVzmoUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/yX3w5/2Cbr/0IV6BXn+sf8l98Of9gm6/9CFVETOgs/8AkpOs/wDYJsP/AEdeVz/w7/5HTx9/2Fl/9Fiugs/+Sk6z/wBgmw/9HXlc/wDDv/kdPH3/AGFl/wDRYp9GLqj0CvOvjZ/yJdp/2EE/9FyV6LXnXxs/5Eu0/wCwgn/ouStcN/GiRV+BnotFcH8R9c13TNU8P2Hh2+W0l1KZ4WLxqylt0YXO5TgDcelVv7G+Kv8A0Mul/wDftf8A4zSVG8VJySuN1NbJM9Forzr+xvir/wBDLpf/AH7X/wCM0f2N8Vf+hl0v/v2v/wAZp+xX86/H/IPaP+VnotFedf2N8Vf+hl0v/v2v/wAZo/sb4q/9DLpf/ftf/jNHsV/Ovx/yD2j/AJWei0V51/Y3xV/6GXS/+/a//GaP7G+Kv/Qy6X/37X/4zR7Ffzr8f8g9o/5Wei0V51/Y3xV/6GXS/wDv2v8A8Zo/sb4q/wDQy6X/AN+1/wDjNHsV/Ovx/wAg9o/5Wei0V51/Y3xV/wChl0v/AL9r/wDGaP7G+Kv/AEMul/8Aftf/AIzR7Ffzr8f8g9o/5Wei0V51/Y3xV/6GXS/+/a//ABmj+xvir/0Mul/9+1/+M0exX86/H/IPaP8AlZ6LRXnX9jfFX/oZdL/79r/8Zo/sb4q/9DLpf/ftf/jNHsV/Ovx/yD2j/lZ6JtXduwN2MZxzilrzr+xvir/0Mul/9+1/+M0f2N8Vf+hl0v8A79r/APGaPYr+dfj/AJC9o/5Wei0V51/Y3xV/6GXS/wDv2v8A8Zo/sb4q/wDQy6X/AN+1/wDjNHsV/Ovx/wAh+0f8rPRaK86/sb4q/wDQy6X/AN+1/wDjNH9jfFX/AKGXS/8Av2v/AMZo9iv51+P+Qe0f8rPRaqDTLUXwu9shlDFl3SuVViMEhCdoOMjIHc+prhf7G+Kv/Qy6X/37X/4zR/Y3xV/6GXS/+/a//GaPZW+2vx/yFz/3Wei1DbWkNosggUjzXMjlnLFmPckknoAPYADoK4D+xvir/wBDLpf/AH7X/wCM0f2N8Vf+hl0v/v2v/wAZo9iv51+P+Qc/91notFedf2N8Vf8AoZdL/wC/a/8Axmj+xvir/wBDLpf/AH7X/wCM0exX86/H/IftH/Kz0WivOv7G+Kv/AEMul/8Aftf/AIzR/Y3xV/6GXS/+/a//ABmj2K/nX4/5B7R/ys9Forzr+xvir/0Mul/9+1/+M0f2N8Vf+hl0v/v2v/xmj2K/nX4/5B7R/wArPRaK86/sb4q/9DLpf/ftf/jNH9jfFX/oZdL/AO/a/wDxmj2K/nX4/wCQe0f8rPRaK86/sb4q/wDQy6X/AN+1/wDjNH9jfFX/AKGXS/8Av2v/AMZo9iv51+P+Qe0f8rPRaK86/sb4q/8AQy6X/wB+1/8AjNH9jfFX/oZdL/79r/8AGaPYr+dfj/kHtH/Kz0WivOv7G+Kv/Qy6X/37X/4zR/Y3xV/6GXS/+/a//GaPYr+dfj/kHtH/ACs9Frzr42f8iXaf9hBP/RclH9jfFX/oZdL/AO/a/wDxms7W/A/xC8R2SWms65pdzAkglVMbMMARnKxA9Ca1owjCopOa0/rsROTlFpJnq1FFFcRuFedfDf8A5HTxx/2EB/6Mmr0WvOvhv/yOnjj/ALCA/wDRk1dFP+HP5fmZS+OJ6LRRRXOahRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/ACX3w5/2Cbr/ANCFegV5/rH/ACX3w5/2Cbr/ANCFVETOgs/+Sk6z/wBgmw/9HXlc/wDDv/kdPH3/AGFl/wDRYroLP/kpOs/9gmw/9HXlc/8ADv8A5HTx9/2Fl/8ARYp9GLqj0Cud8beE/wDhMdFh0/7b9j8u4WfzPK8zOFZcYyP73X2roqKUZOD5luNpSVmeH+LfCWraX4h8OWt54pvdQlvrry4Z5Q+61bfGNy5c8/MDwR90V1f/AArfxH/0ULVPyk/+O0fEj/kdPA//AGED/wCjIa9FrsnXqKnB979F3MI048zR51/wrfxH/wBFC1T8pP8A47R/wrfxH/0ULVPyk/8Ajtei0Vj9Yqd/wX+Rp7KH9XPOv+Fb+I/+ihap+Un/AMdo/wCFb+I/+ihap+Un/wAdr0Wij6xU7/gv8g9lD+rnnX/Ct/Ef/RQtU/KT/wCO0f8ACt/Ef/RQtU/KT/47XotFH1ip3/Bf5B7KH9XPOv8AhW/iP/ooWqflJ/8AHaP+Fb+I/wDooWqflJ/8dr0Wij6xU7/gv8g9lD+rnnX/AArfxH/0ULVPyk/+O0f8K38R/wDRQtU/KT/47XotFH1ip3/Bf5B7KH9XPOv+Fb+I/wDooWqflJ/8do/4Vv4j/wCihap+Un/x2vRaKPrFTv8Agv8AIPZQ/q551/wrfxH/ANFC1T8pP/jtH/Ct/Ef/AEULVPyk/wDjtei013WKNpJGCooLMx6ADvR9Yqd/wX+Qeyh/Vzzz/hW/iP8A6KFqn5Sf/HaP+Fb+I/8AooWqflJ/8drqx4x8OG1+0DXLEw5xv89cdN2fpgE56YBPag+I8eJLbR20q9DXKyPHchoWi8tAMucSFwuSqj5erD3NH1ip3/Bf5B7KH9XOU/4Vv4j/AOihap+Un/x2j/hW/iP/AKKFqn5Sf/Ha7LV9aGlPbQxWdxf3V0zCK3tygYhV3M2XZQABgdepAqzp+o22p6Ta6laPm1uoEuInYYyjKGBPpwaPrFTv+C/yD2UP6ucJ/wAK38R/9FC1T8pP/jtH/Ct/Ef8A0ULVPyk/+O12Vt4k0W9TfaapazL5iRbklBG5/uD/AIF/Ce/bNSafrFnqk0q2MqTRxojiWORWVw+cEYOcfKeSAD2zR9Yqd/wX+Qeyh/Vzif8AhW/iP/ooWqflJ/8AHaP+Fb+I/wDooWqflJ/8drtZte0q21NdOuNRto7xtuIHlAb5vu8e+Dj1xxUA8V6AbCW9GsWRtomVXlEy7QW+7z79vXtmj6xU7/gv8g9lD+rnI/8ACt/Ef/RQtU/KT/47R/wrfxH/ANFC1T8pP/jtdYvizRRBbyXWoW1qbjcYklnTLBX2FsgkYz3zxkZweKXQ/FOleIQ66fcoZ4y4kt2ceYm1yhJAJ4yP1GaPrFTv+C/yD2UP6ucl/wAK38R/9FC1T8pP/jtH/Ct/Ef8A0ULVPyk/+O16LRR9Yqd/wX+Qeyh/Vzzr/hW/iP8A6KFqn5Sf/HaP+Fb+I/8AooWqflJ/8dr0Wij6xU7/AIL/ACD2UP6uedf8K38R/wDRQtU/KT/47R/wrfxH/wBFC1T8pP8A47XotFH1ip3/AAX+Qeyh/Vzzr/hW/iP/AKKFqn5Sf/HaP+Fb+I/+ihap+Un/AMdr0Wij6xU7/gv8g9lD+rnnX/Ct/Ef/AEULVPyk/wDjtH/Ct/Ef/RQtU/KT/wCO16LRR9Yqd/wX+Qeyh/Vzzr/hW/iP/ooWqflJ/wDHaP8AhW/iP/ooWqflJ/8AHa9Foo+sVO/4L/IPZQ/q551/wrfxH/0ULVPyk/8AjtH/AArfxH/0ULVPyk/+O16LRR9Yqd/wX+Qeyh/VzyPxT4U8R+GvDV1q3/Cc6pc/Z9n7rdIm7c6r18w4+9npXpHhiaS48I6PNPI0ssljA7u7EszGMEkk9Saxfin/AMk11X/tj/6OStfwl/yJeif9g+D/ANFrVTm50VKW9/0JjFRnZdjXooorlNgrzr4b/wDI6eOP+wgP/Rk1ei1518N/+R08cf8AYQH/AKMmrop/w5/L8zKXxxPRaKKK5zUKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACvP9Y/5L74c/7BN1/wChCvQK8/1j/kvvhz/sE3X/AKEKqImdBZ/8lJ1n/sE2H/o68rn/AId/8jp4+/7Cy/8AosV0Fn/yUnWf+wTYf+jryuf+Hf8AyOnj7/sLL/6LFPoxdUegUUUVBR518SP+R08D/wDYQP8A6Mhr0WvOviR/yOngf/sIH/0ZDXotdFT+HD5/mZx+KX9dAooornNAooooAKKKKACiiigAooooAKK8c1zxtew65p1ubO6v7nWYYpraODVJbVI1kciOMBSBnABLE8knoBVrwF4os/GeoXVlLb6rZywxCVWXW7p1ZcgEH5xg5I9c89Mc9Tw8lG7/AK/Ex9qm7HrNV9RiefS7qGIbnkhdVGcZJUgVj/8ACP2n/Pzqn/g2uv8A45R/wj9p/wA/Oqf+Da6/+OVlyR7lcz7HOR/D3VL7T7OfUdUt7fUY7GC1zDaPH5Cxo/Ro5lbdukbJDBSABt711dnpD6bfXepyTS6hO9pDbom1VcrEGOASQu5mdifujp2FV/8AhH7T/n51T/wbXX/xyj/hH7T/AJ+dU/8ABtdf/HKOSPcOZ9hl3b6jrN/aXdraz6Pd2PmeXNfRRTxurrhl2xzZzkKc5H3felihudI0KHQLDTdSmitbRLSK/Rrc8CMKHw8gJI75XqO9O/4R+0/5+dU/8G11/wDHKP8AhH7T/n51T/wbXX/xyjkj3DmfYw4fhvM9rqNtqWsm5i1K3tba5xFIXMULSMQHkldlZvMxkH5cfLg4I1dN0u98NTvL5VxrL3FvDAxtYoYQghBAJDSKMsG/hGODwMgVP/wj9p/z86p/4Nrr/wCOUf8ACP2n/Pzqn/g2uv8A45RyR7hzPsY2oeFtS8T6nqi3x/s3Sr9LQyRvEj3DNE7NhXWQhOQvUNweMHmptN8ASWaRm51QXEsctmwfypDlLdmYKfMlcjJc9CAOy9c6f/CP2n/Pzqn/AINrr/45R/wj9p/z86p/4Nrr/wCOUcke4cz7GHceCNTaYadbXsKafNpt1a3NzJbB2Imm3FUG8FW2s3J3LxyO1bekeFP7Kv8ATrkXnm/Ybe8g2+Vt3/aJ45c5ycbfKx3znPGMUv8Awj9p/wA/Oqf+Da6/+OUf8I/af8/Oqf8Ag2uv/jlHJHuHM+x0FFc//wAI/af8/Oqf+Da6/wDjlH/CP2n/AD86p/4Nrr/45RyR7hzPsdBRXPjQLRWBFzqnBzzqtyf/AGpS6WZtN106Y1xLcWtxA9xB58jSSRFGVXXexJK/vFIycjntjA4K2jGpa6m/RRRWRYUUUUAFFFFABRRRQAUUUUAcj8U/+Sa6r/2x/wDRyVr+Ev8AkS9E/wCwfB/6LWsj4p/8k11X/tj/AOjkrX8Jf8iXon/YPg/9FrXQ/wCAvX9EZf8ALz5GvRRRXOahXnXw3/5HTxx/2EB/6Mmr0WvOvhv/AMjp44/7CA/9GTV0U/4c/l+ZlL44notFFFc5qFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8l98Of8AYJuv/QhXoFef6x/yX3w5/wBgm6/9CFVETOgs/wDkpOs/9gmw/wDR15XP/Dv/AJHTx9/2Fl/9Fiugs/8AkpOs/wDYJsP/AEdeVz/w7/5HTx9/2Fl/9Fin0YuqPQKKKKgo86+JH/I6eB/+wgf/AEZDXotcH8R9D13U9U8P3/h2xW7l02Z5mDyKqht0ZXO5hkHaelVv7Z+Kv/QtaX/38X/49XW4c9ONmtL9fMx5uWTumei0V51/bPxV/wCha0v/AL+L/wDHqP7Z+Kv/AELWl/8Afxf/AI9Uewf8y+9Fe0XZ/cei0V51/bPxV/6FrS/+/i//AB6j+2fir/0LWl/9/F/+PUewf8y+9B7Rdn9x6LRXnX9s/FX/AKFrS/8Av4v/AMeo/tn4q/8AQtaX/wB/F/8Aj1HsH/MvvQe0XZ/cei0V51/bPxV/6FrS/wDv4v8A8eo/tn4q/wDQtaX/AN/F/wDj1HsH/MvvQe0XZ/cei1kT+KtGttSewnvNtyk8VsyeU5xJKCUXIGOQDz0HfFcj/bPxV/6FrS/+/i//AB6r9peXMsqHWjZW2otc24ngTWZE2OVbC+WMqCeyZIk6k8U1RS3d/RomVR9PxOM1DQPFrXHhbxB4Rj83ydItYpEW4EW7Zh9jgsu5GyOAecHOOK0/hp4R8R6Xrmoa14qd/tM8IgAmnE0knKncWBPACgDnP0wM0fGf9t/8Kis/s39n/wBjf2ZZ/aPM3/aN+5MbcfLj7nXn73tXouhf22LFv+El/s/7V5h2fYN+zZgYzv5znPtjFdE5NQ6dvMyilc06K8/hm1hZb9UGrSBlLzSskyMi+em5VRgV3iMybTA2Dtzj7lTaDLrLa5CLr+09n2+ZYvOSTyzYbJfLL7hjfvCct+8xtzwTnkubHdUVzvi5tamtbey8OpILmVmlacNsWMIMqC3TmQx5X+Jd/vWVbX+tXmqPdfZtTt9MuLd3t4ZY2EkV15QJVhjIjHzBc8bw3Yx0AdvRVDQzcN4e0433mfaTaxGbzQQ2/YN2c985q/TEFFFFABRRRQAUUUUAFFFFABWcf+R00/8A7B93/wCjLetGs4/8jpp//YPu/wD0Zb00Bu0UUVzmwUUUUAFFFFABRRRQAUUUUAcj8U/+Sa6r/wBsf/RyVr+Ev+RL0T/sHwf+i1rI+Kf/ACTXVf8Atj/6OStfwl/yJeif9g+D/wBFrXQ/4C9f0Rl/y8+Rr0UUVzmoV518N/8AkdPHH/YQH/oyavRa86+G/wDyOnjj/sID/wBGTV0U/wCHP5fmZS+OJ6LRRRXOahRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/YJuv/AEIV6BXn+sf8l98Of9gm6/8AQhVREzoLP/kpOs/9gmw/9HXlc/8ADv8A5HTx9/2Fl/8ARYrh9I+Feuw/H3U9WGrQWcMc0uomW0YNMsdy1wsYUSRMm7KEMCMAHgk9Og8B6Lfz+LvGyReJ9Vt2i1RVeSKK1LTHYPmbdAQD/uhR7VTStuQmz1iiuf8A+Ec1T/odNc/782P/AMjUf8I5qn/Q6a5/35sf/kaosWdBRXP/APCOap/0Omuf9+bH/wCRqP8AhHNU/wCh01z/AL82P/yNRYDoKK5//hHNU/6HTXP+/Nj/API1H/COap/0Omuf9+bH/wCRqLAdBRXP/wDCOap/0Omuf9+bH/5Go/4RzVP+h01z/vzY/wDyNRYDoKK5/wD4RzVP+h01z/vzY/8AyNR/wjmqf9Dprn/fmx/+RqLAdBRXP/8ACOap/wBDprn/AH5sf/kaj/hHNU/6HTXP+/Nj/wDI1FgOgrHn8OrPqT3h1TU499xFP5MdxiMeWCNgXH3Gzlh3IHSq/wDwjmqf9Dprn/fmx/8Akauf1D4d+I7y/lng+JWvW8bnIiWOHC8eyge/AA9qabjsxNJ7m94V/wCRO0b/AK8IP/Ra1bl1SwgsUvZ762jtHAK3DzKI2B6YYnBzWLY2l1qHwzsLOwmWCa402CLziSDGrIoZhj+IKSR7gZx1qtZ+GtU0p7U2slpeJY3Uz20UrmFfLlXJ+6jbWVy4XAxsbHFbz+JmcdjqBd25jLi4iKAAlg4wAeh/HtQxt7yOaBvKnQZimjOGHI5Vh9COD2NcnN4c1qSzvLOKLTbeK9ihVpLaZo/s7IBkJH5ZBAxwSR9O1bvh/TJtH01rCVo5IoZW8iUEl5EJ3ZkyOXySC2TuxuPJIEDLlnptjpysun2dvaq5ywgiVAx98CrNFFMQUUUUAFFFFABRRRQAUUUUAFFFFABWcf8AkdNP/wCwfd/+jLetGs4/8jpp/wD2D7v/ANGW9NAbtFFFc5sFFFFABRRRQAUUUUAFFFFAHI/FP/kmuq/9sf8A0cla/hL/AJEvRP8AsHwf+i1rI+Kf/JNdV/7Y/wDo5K1/CX/Il6J/2D4P/Ra10P8AgL1/RGX/AC8+Rr0UUVzmoV518N/+R08cf9hAf+jJq9Frzr4b/wDI6eOP+wgP/Rk1dFP+HP5fmZS+OJ6LRRRXOahRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAV5/rH/JffDn/AGCbr/0IV6BXn+sf8l98Of8AYJuv/QhVREzoLP8A5KTrP/YJsP8A0deVyvgTVLCy8cePY7y+trdzqqsFlmVSR5fXBPtXVWf/ACUnWf8AsE2H/o68qDUfhv4P1bUJr7UdAtLi6nbfLK6nLn1PNO66i16Gv/b+j/8AQWsf/AlP8aP7f0f/AKC1j/4Ep/jXP/8ACpvAn/QsWP8A3yf8aP8AhU3gT/oWLH/vk/40vdHqdB/b+j/9Bax/8CU/xo/t/R/+gtY/+BKf41z/APwqbwJ/0LFj/wB8n/Gj/hU3gT/oWLH/AL5P+NHuhqdB/b+j/wDQWsf/AAJT/Gj+39H/AOgtY/8AgSn+Nc//AMKm8Cf9CxY/98n/ABo/4VN4E/6Fix/75P8AjR7oanQf2/o//QWsf/AlP8aP7f0f/oLWP/gSn+Nc/wD8Km8Cf9CxY/8AfJ/xo/4VN4E/6Fix/wC+T/jR7oanQf2/o/8A0FrH/wACU/xo/t/R/wDoLWP/AIEp/jXP/wDCpvAn/QsWP/fJ/wAaP+FTeBP+hYsf++T/AI0e6Gp0H9v6P/0FrH/wJT/Gj+39H/6C1j/4Ep/jXP8A/CpvAn/QsWP/AHyf8aP+FTeBP+hYsf8Avk/40e6Gp0H9v6P/ANBax/8AAlP8aQ+ItEU4bWLAH0N0n+NYH/CpvAn/AELFj/3yf8ajl+D/AMP5pN8vhWwdsAZKnsMDv6UnboCv1L3h2eK18C6VcXDrHDFpsLyO3RVEQJJ/Co38W2n9n2N1Fa3MpvWdEh/dxvGyZDq291AKkEEZ6imaTpsOr/DzS7C6LiCawtxKqHG9Nikof9lgCp9ienWlHgrRsskkBmtmlkl+yy4eIF0CNgEZwcZ69WY966J/EzKOwlt4ysbyWEWltcyxSQRzmXMahEddw+UuHPH91T7ZpI/GdnLpK6gtld+XI8aRDMWJd/3Sr79nY5BYEdwMjKReDYIrpZ11O/LCKOJi3kszqgwPnMe8HHdWB79eaYfBFo8c/mX92888kUj3Bjg3Ex7tuVEewn5jklSTxzwMRqPQuTeIjCdPH9k30hv3McflvAQrBWbaT5uPuoxyMjtnPFO0rxPp2sypFZNIZG84FXTaUMTIGBHbPmIR6gg1NHo0SR6csk80rafM00blUXcSjphgihcYkPQDoPfNex8LWGnavBqVs0wuIbV7U5cbZFZ1fLDH3gVwCMcEg54wAbVFFFMQUUUUAFFFFABRRRQAUUUUAFZx/wCR00//ALB93/6Mt60azj/yOmn/APYPu/8A0Zb00Bu0UUVzmwUUUUAFFFFABRRRQAUUUUAcj8U/+Sa6r/2x/wDRyVr+Ev8AkS9E/wCwfB/6LWsj4p/8k11X/tj/AOjkrX8Jf8iXon/YPg/9FrXQ/wCAvX9EZf8ALz5GvRRRXOahXnXw3/5HTxx/2EB/6Mmr0WvOvhv/AMjp44/7CA/9GTV0U/4c/l+ZlL44notFFFc5qFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABXn+sf8l98Of8AYJuv/QhXoFef6x/yX3w5/wBgm6/9CFVETOX034vRH44arpVxos6xv/xLTNbs9w4+yvctvESRlm3b8YH3cZyR09I/4TXS/wDn11z/AMEF9/8AGaz9O0DR4Pitq95BpNjHdLp1pOs6WyBxJJLdiRwwGdzAAMepwM12FOVhK5z/APwmul/8+uuf+CC+/wDjNH/Ca6X/AM+uuf8Aggvv/jNdBRU6D1Of/wCE10v/AJ9dc/8ABBff/GaP+E10v/n11z/wQX3/AMZroKKNA1Of/wCE10v/AJ9dc/8ABBff/GaP+E10v/n11z/wQX3/AMZroKKNA1Of/wCE10v/AJ9dc/8ABBff/GaP+E10v/n11z/wQX3/AMZroKKNA1Of/wCE10v/AJ9dc/8ABBff/GaP+E10v/n11z/wQX3/AMZroKKNA1Of/wCE10v/AJ9dc/8ABBff/GaP+E10v/n11z/wQX3/AMZroKKNA1Of/wCE10v/AJ9dc/8ABBff/Ga5/UPjN4c02/ltJ7DXmkiOCV0iYDpnoQCOvQgGvQKKNBnIabdzWPw3064tEjkuE02DykkcKrOUUKMkgckgYyMnjIzms6XxffxafOQts11Zx3M84kgki+WFI3MZRjlHYSrg7nXA3c5wNrw5BDdeBtJguYkmhk06FXjkUMrgxjIIPBFWhoOkC1S1GlWQt45PNSL7Om1X/vAYwDz1refxMxjsUfDmuXOryuLlIVV7SC8i8sEFElMgCNknLDy+SMcnGBjmnrvjSPRPECWTQ+bAkO6dlBLB2DGNQenJj2kHnMseO9bT6PBGkn9mN/Zck0nmSy2cMQaU8/e3IQeTnOM+/WpYtNt1t2jnRLlpHWWWSWJN0rrt2u21QCw2rg442j0qRmLBreoxGx+2yadN9uaEqlvuV41fdnIJO4DAw/GeflFLP4lnTxeNESBUUun+lSq3l4KFygPeQgHA4AAJPZW0R4b0MW8kA0bTxDKytJH9lTa5XO0kYwSMnHpmrC6Vp6QiFLG2WIFCEEKhQUIKHGP4SBj0wMUAW6KKKYgooqG3vLa7837JcRT+TIYpfKcNscdVOOhHoeaAJqKht7y2u/N+yXEU/kyGKXynDbHHVTjoR6HmuH8V+K9X0i+1u3s3TP2MfYCYwfKlVN7k/wB75CzgH/nkfWh6Bud9RXA3fii9TxBFaSaolnBNPcR3bFY86ekbKImyw480EcvkHeNuMc9Vp2qk+EbTVtVZYSbFLm5baVCfuwzHHYDmkM1KK87HjHXo7B45LWQaysgnTTpLf5pLeRCScLz+6ZXGf4vLA+9IK6bQ9VkvtWvYBdrd2sNrayQzKoHmb1cl8jjnAPpRcDerNYgeNNPycf8AEvu+v/XS3riPEXiLxVB4+0WC20KVYxJdrBbpqSKuoqE+8w6LtGGAbPXA5roNVuZxNbXV1Gtlcf2HeySRvIzCB/3BILx/MQD3XnjIrb2bVvMjmOyjmilaRYpEcxttcKwOw4BwfQ4IP0Ip9cZrXiTU/Dl9ImmeF77VluZPMeWEYAIRF/gRien8XPB/h21m/wDCyPEf/RPdU/OT/wCNVkqE3qvzRftIrc9Forzr/hZHiP8A6J7qn5yf/GqP+FkeI/8AonuqfnJ/8ap/V6nb8V/mP2sP6uei0V51/wALI8R/9E91T85P/jVH/CyPEf8A0T3VPzk/+NUfV6nb8V/mHtYf1c9Forzr/hZHiP8A6J7qn5yf/GqP+FkeI/8AonuqfnJ/8ao+r1O34r/MPaw/q56LRXnX/CyPEf8A0T3VPzk/+NUf8LI8R/8ARPdU/OT/AONUfV6nb8V/mHtYf1c1/in/AMk11X/tj/6OStfwl/yJeif9g+D/ANFrXnXinxX4j8S+GrrSf+EG1S2+0bP3u2R9u11bp5Yz93HWvSPDEMlv4R0eGeNopY7GBHR1IZWEYBBB6EVU4uFFRlvf9CYyUp3XY1KKKK5TYK86+G//ACOnjj/sID/0ZNXotedfDf8A5HTxx/2EB/6Mmrop/wAOfy/Myl8cT0Wiiiuc1CiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAr5X1Z/Hcfx7L2sWsTXC6tKbCO4aZY3tvtHQHtARjJHy7favqivP8AWP8Akvvhz/sE3X/oQq4O1yJK5j22q/EkeN9TdPDmjG8bTrMSxm+basYkudhBxySTJkdto9a2P7Y+Kf8A0K+h/wDgwb/Cugs/+Sk6z/2CbD/0deV0FDfkNLzPP/7Y+Kf/AEK+h/8Agwb/AAo/tj4p/wDQr6H/AODBv8K9Aopc3kO3mef/ANsfFP8A6FfQ/wDwYN/hR/bHxT/6FfQ//Bg3+FegUUc3kFvM8/8A7Y+Kf/Qr6H/4MG/wo/tj4p/9Cvof/gwb/CvQKKObyC3mef8A9sfFP/oV9D/8GDf4Uf2x8U/+hX0P/wAGDf4V6BRRzeQW8zz/APtj4p/9Cvof/gwb/Cj+2Pin/wBCvof/AIMG/wAK9Aoo5vILeZ5//bHxT/6FfQ//AAYN/hR/bHxT/wChX0P/AMGDf4V6BRRzeQW8zz/+2Pin/wBCvof/AIMG/wAKim1r4tLKRB4T0FkwMFtRYHOOe3rXotFJu4JHG2nnf8KvsvsrzxynS4Qr28ZkdMxryFBBOOuFO705xWFJPrX9iSCKLVkEf2kWzJ57s84jQwn51Egj3GTIkyu4ckrtrqvDk8Vt4H0ia5lSGJNPgLySMFVR5a8knpWhcahZ2glN1dwQCFVeUyShdisSFJyeASCAe5BrefxMyjsYXhN9Ree5/tD7Z/x7wmb7SrhRclpfOEe7+DiPG35cYx1NU/EV54gTXXn0y0u30+0QW7iLOZWlU5dUxlghaE7h02yj1ro7tdJ1GVLC/Wzu5CvnpbzBHJHTeFPbqM1PGLSwigtohDbRs3lwxLhATgnao9cAnA9DUjPPDD4hs7N4rv8AtEB/sbbYZbucFct5jFxmRWzgMi4AAB5ycXtWmv0s9Pkshqz+XA5WCNbtTJJv/vsCwYY4E6lCCOQAa7NtSsUvTZve263QTeYDKocL1ztznHvUkl3bRRs8txEiKnmMzOAAn976e9FgOSsop7vxVqEGo/2ksb3EixMsl7GoTaCNrLiIDg8g5/Gsq4j8Taf4ZtrrTv7UnnXQ99zbSNJJJJO6DcV3EkSq2GCjtuAGSMekUUWAaudoz1xzXFzPZrv+2SW6Y1x2P9gEf6sY3/bPbp5vb7ma7aobeztrTzfslvFB50hll8pAu9z1Y46k+p5q4ysS1czPD3/MU/5BX/IRm/5Bv4f67/pt/e/CtmobeztrTzfslvFB50hll8pAu9z1Y46k+p5rh/Ffh7Xr6+1v+yo3MGqWYtnInVcbE3KQCRjJ3xnp/rAegzSk7u40jvaqNpkD3/2wyXXm5B2i7lEfAx/qw239K4/UfDmqXi61GtrMstxZ3qfaY7kRm6d3Rrdchg3yKpT5sAcjkMa6q91uztmmtobm2m1FEJjsftCLJI+3KpgkYJ46+tSM0qK87HhrxVFYPpqSx/aDILuPVI5yixuyETx4zu+dhnIGB5pYcoorptDsrqDVr24ls2s7Wa1tUhhZ1byyqvuT5SRxkDPQ9s0AaNz/AGb/AGnZfbPsn27959j83b5vT5/Lzz0647dapagYB4mtDeSGKD+zLzzJBJ5exd9vk7gRtwO+RiuQ8ReHfFNx4+0We316Vo2ku2guF01GXTlKcKx6NuGFBbHTPWug1VLi2mtkuLlp7mPQ70PcI625dx5GXDfdjJPOei/hW6ik1Z/1qZt76HS6WuLrUyFcK10CC0ITP7mPkEffH+0ec5XoorQrjNa0/wAXXV9I3hHU7Gwi8z9+JrbaXbYmDuKNv443DA6L1U1m/wBjfFX/AKGXS/8Av2v/AMZrL2SlrzJf16GinbSzPRaK86/sb4q/9DLpf/ftf/jNH9jfFX/oZdL/AO/a/wDxmj2K/nX4/wCQ/aP+VnotFedf2N8Vf+hl0v8A79r/APGaP7G+Kv8A0Mul/wDftf8A4zR7Ffzr8f8AIPaP+VnotFedf2N8Vf8AoZdL/wC/a/8Axmj+xvir/wBDLpf/AH7X/wCM0exX86/H/IPaP+VnotFedf2N8Vf+hl0v/v2v/wAZo/sb4q/9DLpf/ftf/jNHsV/Ovx/yD2j/AJWei0V51/Y3xV/6GXS/+/a//GaP7G+Kv/Qy6X/37X/4zR7Ffzr8f8g9o/5Wei0V51/Y3xV/6GXS/wDv2v8A8Zo/sb4q/wDQy6X/AN+1/wDjNHsV/Ovx/wAg9o/5Wei1518N/wDkdPHH/YQH/oyaj+xvir/0Mul/9+1/+M1o+AfCeseHL3WbvXbm1uZ9SkSUvbk8sC5YkFVAyX7VfLGFOS5k72/Mm7lJaHaUUUVyGwUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFef6x/wAl98Of9gm6/wDQhXoFeG6n8T9El/aA0wGG8jGnmfR5nkRAvmtLs3g7/uAjJJwcdquKbJk0iHSPhXrsPx91PVhq0FnDHNLqJltGDTLHctcLGFEkTJuyhDAjAB4JPT1j/hHNU/6HTXP+/Nj/API1UbPW9KHxE1iQ6nZhG0qwVW+0JgkS3eRnPbI/MVvf2/o//QWsf/AlP8aJNsSSRn/8I5qn/Q6a5/35sf8A5Go/4RzVP+h01z/vzY//ACNWh/b+j/8AQWsf/AlP8aP7f0f/AKC1j/4Ep/jU6laGf/wjmqf9Dprn/fmx/wDkaj/hHNU/6HTXP+/Nj/8AI1aH9v6P/wBBax/8CU/xo/t/R/8AoLWP/gSn+NGoaGf/AMI5qn/Q6a5/35sf/kaj/hHNU/6HTXP+/Nj/API1aH9v6P8A9Bax/wDAlP8AGj+39H/6C1j/AOBKf40ahoZ//COap/0Omuf9+bH/AORqP+Ec1T/odNc/782P/wAjVof2/o//AEFrH/wJT/Gj+39H/wCgtY/+BKf40ahoZ/8Awjmqf9Dprn/fmx/+RqP+Ec1T/odNc/782P8A8jVof2/o/wD0FrH/AMCU/wAaP7f0f/oLWP8A4Ep/jRqGhn/8I5qn/Q6a5/35sf8A5Go/4RzVP+h01z/vzY//ACNWh/b+j/8AQWsf/AlP8aP7f0f/AKC1j/4Ep/jRqGhn/wDCOap/0Omuf9+bH/5Grn9Q+HfiO8v5Z4PiVr1vG5yIljhwvHsoHvwAPauw/t/R/wDoLWP/AIEp/jSHxFoinDaxYA+huk/xo1A5y20v+2vhhp+nYjYXGn26sJPuldqEg/gDWfYeENYs9QOpTT2t5dg2+VklZVmEKzRjcdpI+SRH6H5w3bBrW03VINF+G+najdrI8NvpsDssS7mP7teAO5qZ/Fun/wBoTWVqs13cxrAVSBQfNModlVSSBnbGzHJAAxzW8/iZlHYyLDw9d6C2nSXDRTWtk0MskkKSSSlltDbbFjVSSuTvznjLcd6m1vSL7xPPFe6bdfZFso99olxbuha4Dh8urqCqjy0GRkkPIPrqWniewvrq1itRM8d0E8ufZhN7RGYIcnIbyxu6YxjnJxVnUdZtNLubKC6LB7yURR7VztyQAzeg3Mi59XX1qRmM+hanm9tkh06W3urmW5FzO7NKjPGVwF2YBBO0Nu+527VTm8Ma1fT2d5cGzgn0+CNYbdLlpYbh0YEeZmNTjrjAO04bBKitWTxhYw6k9nLBcLtleES5jKs6RmQgKH3/AHVPJUDjrUY8aWptbeY6fdA3ThII/Nt90hKluD5u0cDoSCewPODQDox05paxl8SQSaslhDZ3LOVjZnYxxiMOMjKu4fOOoCnFVZfGdrafaW1GwvrKG1uUtpppRGyo7BWGdjsdoVwxbGAM56GmB0dFV7K9iv4Hlg3bUmkhO4Y+ZHKN+qmrFAgooooAKKKKACiiigArNYA+NNPyM/8AEvu+v/XS3rSrOP8AyOmn/wDYPu//AEZb00BrwWkNtJPJAmxriQSSnJ+Ztqpn2+VVHHpU1FFc5sFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFeE638KfD8vx4sIbiS8nh1UXGq3MUjoVaQSbtg+X7hyQR1x3r3avP9Y/5L74c/7BN1/wChCri2iZJMq2vwy8GP481Szbw7Zm3i02yljj2nCu8t0GPXuET/AL5FbX/Cp/An/QsWP/fJ/wAakudTj0X4gajcXtpqTwXOl2ccUtrptxcqWSW6LKTEjAEB0ODj7wq5/wAJrpf/AD665/4IL7/4zQ3ILRM//hU/gT/oWLH/AL5P+NH/AAqfwJ/0LFj/AN8n/GtD/hNdL/59dc/8EF9/8Zo/4TXS/wDn11z/AMEF9/8AGaXvB7pn/wDCp/An/QsWP/fJ/wAaP+FT+BP+hYsf++T/AI1of8Jrpf8Az665/wCCC+/+M0f8Jrpf/Prrn/ggvv8A4zR7we6Z/wDwqfwJ/wBCxY/98n/Gj/hU/gT/AKFix/75P+NaH/Ca6X/z665/4IL7/wCM0f8ACa6X/wA+uuf+CC+/+M0e8Humf/wqfwJ/0LFj/wB8n/Gj/hU/gT/oWLH/AL5P+NaH/Ca6X/z665/4IL7/AOM0f8Jrpf8Az665/wCCC+/+M0e8Humf/wAKn8Cf9CxY/wDfJ/xo/wCFT+BP+hYsf++T/jWh/wAJrpf/AD665/4IL7/4zR/wmul/8+uuf+CC+/8AjNHvB7pn/wDCp/An/QsWP/fJ/wAaP+FT+BP+hYsf++T/AI1of8Jrpf8Az665/wCCC+/+M0f8Jrpf/Prrn/ggvv8A4zR7we6Z/wDwqfwJ/wBCxY/98n/Go5fg/wCAJpN8vhWwdsAZKnsMDv6Vqf8ACa6X/wA+uuf+CC+/+M1z+ofGbw5pt/LaT2GvNJEcErpEwHTPQgEdehANJ36jVuhq6LYx6l4A0m1nZ1R7C3yUIB4RT3+lRWvgjT7H5rK6vIZlKGOYMhaPYZNoGVIICStHyD8oXuM1Hb39zpfwtsbywjjluo9Nt/KSUkKzFFABx25qpbeNLnVtWa00yGGKGYWotridS2GkSZ3LKCM4EWwAEHdnJrefxMyjsaUfhaLTWtptKaSRrTyzFazTBImdYvJDswRm3eWcehwOM80X3hiDxBvn16Hy7kwGCIW9wXFuM7vMRiikOTtPII/drjocu0vX7rUbzRw1rDHbajpTXxYSFmWQGL5AMY24l6559B3j8S+K08P39hAVVllbzLlmB/dQhlQtx0IL7ueNsb96nQZLJ4Q02S5a6Bljunkkd7hNodxIu1kJ28oeDj1UHtUCeC4Y9PFmuq3vlbQhUw221lxjDL5O1uxywJGOCMnJJr1/m9u0axitLW4lthBPuWV2RCdwbOMkjhNvK87u1Raj4suLO80+1S2QG+t4n+0OreVbs7BcuR2yQAOpYgZAywNALVt4RtbK/gubS8uo/JihiEZWFwyxDauWaMvyOpDD8KuyaDaSzTySNI3n3i3bqSCpZY1jxjH3dqDj1zzWnRTAztD0W28P6UmnWLStAkkjp5r7mXe7Ptz6DdgZ5wBknrWjRRQIKKKKACiiigAooooAKzj/AMjpp/8A2D7v/wBGW9aNZx/5HTT/APsH3f8A6Mt6aA3aKKK5zYKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAK8/wBY/wCS++HP+wTdf+hCvQK8+8Z6L4q/4WDo/iPwpY2V6LOzlt5Y7ufywd57Yqo7ilseg0V5/wD2x8VP+hW0P/wYN/hR/bHxU/6FbQ//AAYN/hRyhc9Aorz/APtj4qf9Ctof/gwb/Cj+2Pip/wBCtof/AIMG/wAKOULnoFFef/2x8VP+hW0P/wAGDf4Uf2x8VP8AoVtD/wDBg3+FHKFz0CivP/7Y+Kn/AEK2h/8Agwb/AAo/tj4qf9Ctof8A4MG/wo5QuegUV5//AGx8VP8AoVtD/wDBg3+FH9sfFT/oVtD/APBg3+FHKFz0CivP/wC2Pip/0K2h/wDgwb/Cj+2Pip/0K2h/+DBv8KOULnoFFef/ANsfFT/oVtD/APBg3+FH9sfFT/oVtD/8GDf4UcoXPQKK8/8A7Y+Kn/QraH/4MG/wqKbWvi0shEHhPQWTAwW1Fgc457etJqwJ3Og8Nwxz+CdHjnjSRDYQZV1BB+RT0NW20XS3hkhfTbNopDl0MC7X+cvyMc/MzN9WJ6msJI7ub4U2UWnSzw3MmnW6RyW4PmJlUBK+4GTWVBd+ILy/mudXi1K3sJBapNDbxyBowonWQpsG7mUISV5MZU9K3n8TMo7HbT2EckKrbt9kkjTy4poY03xJlSVXcpAB2rkY7D0FMh0uFYZkvG+3PPH5U0tzFHukj5wjbVAKjc3BH8R9ayNIGsG/0OXUJroq+jN9riZAEW4Bg+ZsD75y4xnHBwOtReKrvXI9Qtm0S1uJYbBPtlyI+PPG7HlLx85KCX5R0Yxn0qRm42jaW96bx9NtGuiu0zmBS5G3bjdjONvH04qODw/o1rbywW2k2MMMyGOWOO2RVkU8FWAGCPY1ydzF4gTXJrtPtq2r3VwimOSZ22+S3lqYj8ioW53gZBAH8RIpxPfnRbfJ1hZAytOpj1E+Ydh+Usf3ic5OUDLkYYcrQB6QBgYFLXDWc2oyeJrV9Qi1ONWgtSqP9qKqxX5wxiAhJDfeLAD6Cn3Ol6rFNqA0q71KGb+1IktpJp5poxF5MbnKsxBQybgxHOMjIxwAdtRWN4Wub670Pz9Vtp7W5a5uN0M/3o185woz3XbjBHBGCOK2aYgooooAKKKKACiiigArOP8AyOmn/wDYPu//AEZb1o1nH/kdNP8A+wfd/wDoy3poDdooornNgooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigDnfCv/InaN/14Qf+i1rWrndI1ew0bS4dJ1e7gsLrT4lgZLmZU3qo2rIpOMqwAOR3OOoq5/wlXh7/AKDumf8AgZH/AI11yjJybSOdNJGhc2tve27QXkEdxC2N0cqBlODkZB460lpZWthB5NjbQ20Wc+XDGEXPrgVQ/wCEq8Pf9B3TP/AyP/Gj/hKvD3/Qd0z/AMDI/wDGp5Jdh8yNaisn/hKvD3/Qd0z/AMDI/wDGj/hKvD3/AEHdM/8AAyP/ABo5JdgujWorJ/4Srw9/0HdM/wDAyP8Axo/4Srw9/wBB3TP/AAMj/wAaOSXYLo1qKyf+Eq8Pf9B3TP8AwMj/AMaP+Eq8Pf8AQd0z/wADI/8AGjkl2C6Naisn/hKvD3/Qd0z/AMDI/wDGj/hKvD3/AEHdM/8AAyP/ABo5JdgujWorJ/4Srw9/0HdM/wDAyP8Axo/4Srw9/wBB3TP/AAMj/wAaOSXYLo1qKyf+Eq8Pf9B3TP8AwMj/AMaP+Eq8Pf8AQd0z/wADI/8AGjkl2C6Nas4/8jpp/wD2D7v/ANGW9RjxRoDMAuuaaSTgAXcfP60ml3MeseJBf2JE1laWskC3KNlJXkdCQp7hRGMkcZbHY4LNJtjTTeh0VFFFcxsFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQBgTeJEi8WJphkt/JJWFgX/eiZlLjjP3cBR06uPSql94lvrZtWt41tjPplvNctIQSsihNyKBnORkbvTj++Mb7aXZvbSQNDmOWbz3G85L7g27Oc5BAI9MDFQTeH9MuLMW01tui/ef8tGDHzAQ+WByd245yfQ9hWylT6ohqQuq6i+nz2AVVZLid0kyOdohkk498oP1rM/4S0G8tYzZSQpJGJ5WlZSVhaN2Vhgnn922R7e9btzZW94Yjcx7zCxdPmIwSjIen+y7D8arNoWnNLFIbf54o0jQ+Y33UDhVIzyMSOMHrnnOBUxcLaobUuhQh8W29xbtJBbSyybolWNJI23eYSF5DYByDkE8flUyeIg8Ecq2FwUuHCWxyn745I/vccAnnt78VZh0OwgVVSORgrIy+ZO7ldn3QCxOAMnjpzTD4e00knyZAc7lInceWd275Pm+Tn+7inen2FaRVm8VQwwtJ9iuGEUUstwAUzCsTbXzzyQQcYzkUHxXbRxPLc208MQikkjZin7wRusbAc8fMy4zjrV3+wtONs8BtyY5IZIHBkYlkc5fJzkkkkk9eetK2h6c8Sxtb5VY5IgN7cLIwZu/dlU56jHGKL0+wWkUrXxPFfTNDZ2c1xLEf3widGCDjkNuw2c9vQjgjFXdGv5dS077RPCIW82RNoOeFcqD+lRt4e05uXjlYnO9muJCZAcZDHdlh8o4ORV21tIbONo7dSqNI0hBct8zHJxk8DJPA4pScLe6hrmvqTUUUVmUFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAf//Z"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Diagram.JPG](attachment:Diagram.JPG)"
   ]
  },
  {
   "attachments": {
    "Address%20Editor.JPG": {
     "image/jpeg": "/9j/4AAQSkZJRgABAQEAeAB4AAD/4RDaRXhpZgAATU0AKgAAAAgABAE7AAIAAAAFAAAISodpAAQAAAABAAAIUJydAAEAAAAKAAAQyOocAAcAAAgMAAAAPgAAAAAc6gAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGRlbGwAAAAFkAMAAgAAABQAABCekAQAAgAAABQAABCykpEAAgAAAAMzMgAAkpIAAgAAAAMzMgAA6hwABwAACAwAAAiSAAAAABzqAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMjAxOTowMzoxNCAxMTozMzowOAAyMDE5OjAzOjE0IDExOjMzOjA4AAAAZABlAGwAbAAAAP/hCxdodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvADw/eHBhY2tldCBiZWdpbj0n77u/JyBpZD0nVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkJz8+DQo8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1ldGEvIj48cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPjxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSJ1dWlkOmZhZjViZGQ1LWJhM2QtMTFkYS1hZDMxLWQzM2Q3NTE4MmYxYiIgeG1sbnM6ZGM9Imh0dHA6Ly9wdXJsLm9yZy9kYy9lbGVtZW50cy8xLjEvIi8+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iPjx4bXA6Q3JlYXRlRGF0ZT4yMDE5LTAzLTE0VDExOjMzOjA4LjMyMDwveG1wOkNyZWF0ZURhdGU+PC9yZGY6RGVzY3JpcHRpb24+PHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9InV1aWQ6ZmFmNWJkZDUtYmEzZC0xMWRhLWFkMzEtZDMzZDc1MTgyZjFiIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iPjxkYzpjcmVhdG9yPjxyZGY6U2VxIHhtbG5zOnJkZj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+PHJkZjpsaT5kZWxsPC9yZGY6bGk+PC9yZGY6U2VxPg0KCQkJPC9kYzpjcmVhdG9yPjwvcmRmOkRlc2NyaXB0aW9uPjwvcmRmOlJERj48L3g6eG1wbWV0YT4NCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgPD94cGFja2V0IGVuZD0ndyc/Pv/bAEMABwUFBgUEBwYFBggHBwgKEQsKCQkKFQ8QDBEYFRoZGBUYFxseJyEbHSUdFxgiLiIlKCkrLCsaIC8zLyoyJyorKv/bAEMBBwgICgkKFAsLFCocGBwqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKv/AABEIAQoC5AMBIgACEQEDEQH/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/xAAfAQADAQEBAQEBAQEBAAAAAAAAAQIDBAUGBwgJCgv/xAC1EQACAQIEBAMEBwUEBAABAncAAQIDEQQFITEGEkFRB2FxEyIygQgUQpGhscEJIzNS8BVictEKFiQ04SXxFxgZGiYnKCkqNTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqCg4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2dri4+Tl5ufo6ery8/T19vf4+fr/2gAMAwEAAhEDEQA/APoX7c3/ADx/8eo+3N/zx/8AHqrVzMXji1laGcaZqS6TPKIotXZI/s7ljtU43+YFLcBygU5Bzgg0B0udf9ub/nj/AOPUfbm/54/+PVkDW9LbU59Nj1G1k1C3j82WzSdTMi4ByUzkDkckdx61T0LxTZeIXRbKK4QtYW9+PNVR+7m37RwT8w2HPbpyaNwOj+3N/wA8f/HqPtzf88f/AB6q9FAFj7c3/PH/AMeo+3N/zx/8eqvRQBY+3N/zx/8AHqPtzf8APH/x6q9FAFj7c3/PH/x6j7c3/PH/AMeqvRQBY+3N/wA8f/HqPtzf88f/AB6q9FAFj7c3/PH/AMeo+3N/zx/8eqvRQBY+3N/zx/8AHqPtzf8APH/x6q9FAFj7c3/PH/x6j7c3/PH/AMeqvRQBY+3N/wA8f/HqPtzf88f/AB6q9FAFj7c3/PH/AMeo+3N/zx/8eqvRQBY+3N/zx/8AHqPtzf8APH/x6q9FAFg35AJMPA/2qPtzf88f/HqqSf6p/wDdNOJCqSxwAMk0AWftzf8APH/x6j7c3/PH/wAerkbDxva301oW0zUbaz1AMbC+nWMRXWFLgKFcuu5FZhvVcgevFW7fxfocul6Ve3Wo22njVokltIb2dIpJNwBCgFuT8wGBnk07MDo/tzf88f8Ax6j7c3/PH/x6s8X9myxst3AVkkMKESDDuM5UerDa2R14PpUWmaxpmtW7z6NqNpqEKOY2ktZ1lVWABKkqSAeRx70gNX7c3/PH/wAeo+3N/wA8f/Hq5qPxnoQ083t/qNtpkXnzQA386Q5MUpiYjLdNw4+o6ZxSp4w0R9evtIN/AlxYWiXk7NMgVYmz833sjAAJJAADqc80B/X6HSfbm/54/wDj1H25v+eP/j1YbeJtBXSo9TbW9OGnykrHdm7j8pyM5AfODjB79jWVpvxF8NajY3V+2p2tnYW921ot3dXkCRzOuc7SHJ7ZG4KSOQCDmgPM7H7c3/PH/wAeo+3N/wA8f/HqyLzXNJ0+S1S/1SytXvW22qz3CIZzxwmT8x5HT1FOj1jTJtXl0qLUbR9RhTzJLNZ1MyLx8xTOQORzjuPWgDV+3N/zx/8AHqBfk9If/Hqr0yP7p/3j/OgC39ub/nj/AOPUfbm/54/+PVx9743Szu9TRNC1W5tdKfZeXsHkeXH+7WQna0okYBXBOEJ9Aa131/R4tSt9Ol1WyjvrlA8FpJcKssqnOCqE7j0PbsaA2Nn7c3/PH/x6j7c3/PH/AMerJh1vSrjVptKt9Ts5dRgXdLZpcK00Y45ZAcgcjqO4pbLWNM1G6urbT9RtLu4s22XMUE6u8DZIw4BypyDwfQ0Aav25v+eP/j1H25v+eP8A49XO2PinT7/XdV0iITJd6WV80SJgSAorZQ5+YDeoPcEjPUEpb+L9Dl0vSr261G208atEktpDezpFJJuAIUAtyfmAwM8mjf8AruB0f25v+eP/AI9R9ub/AJ4/+PVjXHiDRrTUEsLrV7GC8kbaltJcosjHAOApOScEH6EU1PEmhyaM+rx61p76bGdr3q3SGFTkDBfO0ckDr3oA2/tzf88f/HqPtzf88f8Ax6qVvcwXlrFc2k0c8EyB45YmDK6kZBBHBBHepaALH25v+eP/AI9R9ub/AJ4/+PVXooAsfbm/54/+PUfbm/54/wDj1V6KALH25v8Anj/49R9ub/nj/wCPVXooAsfbznHk8/71H25v+eP/AI9VQf61v90f1rO1fXE0qS3gjs7rULy53GG0tAnmMq43Nl2VVUZGSzDkgDJIFAG59ub/AJ4/+PUfbm/54/8Aj1cPqPxM0LSrO3k1Dzba5muzZvZ3EkUMsMirubeXcJtClTuDEHcu3duGbei+PvD+s6ZYXv2+3sRqTlbKG7u4VkuMED5VV2yckDb94HggHiha7A9Nzrftzf8APH/x6j7c3/PH/wAerKl1nTINWh0ufUbSLUJ0LxWjzqJZF55VCckfKeQOx9KreHfEumeKdOlvdHuEnhiuJLdyrq2GRip+6SMEAMPVWB70Ab325v8Anj/49R9ub/nj/wCPVg6Z4k07VNNutQil8m1tJHSWWcqqqqjO/OcbCpDA+hBOKr2njTQL231C6i1O1WwsHRJb9riMW7b1BBWTdjHzAc454oA6b7c3/PH/AMeo+3N/zx/8ermrDxloN/Cki6lbQrLcvbW/nTxr9oZWC5j+b5gSRjHXI9av2mtaVf3F3BY6lZ3M1k226jhnV2gPPDgHKng9cdDR0uBrfbm/54/+PUfbm/54/wDj1Ylr4j0S+0ufUrLWdPuLC3z511DdI8UWBk7nBwMAg8nvVqw1Gy1WyS80u8t721kzsnt5VkRsHBwykg8gigDRN+R1h/8AHqPtzf8APH/x6qkn3R/vD+dVNZ1WHQ9DvdVu0keCygeeRYgCxVRkgZIGePUUDSu7I1vtzf8APH/x6j7c3/PH/wAerl7TxW0up2llqWhanpLXpZbaW7Nu6SuFLbP3UrkHaGPIA+U854q7D4j0O5kvI7fWdPlexybtY7pGNvjIO8A/LjB646UCNv7c3/PH/wAeo+3N/wA8f/HqxrXxBo17aXV1ZatY3FvZlhczRXKOkGBk72BwuByc0xPE2gyaVLqcet6c+nwkCS7W7jMSE4xl84HUd+9AG59ub/nj/wCPUfbm/wCeP/j1Ure5gvLWK5tJo54JkDxyxMGV1IyCCOCCO9S0AWPtzf8APH/x6j7c3/PH/wAeqvRQBYN+QCTDwP8Aao+3N/zx/wDHqqSf6p/900ruI42c9FBJxQ3ZXAtfbm/54/8Aj1H25v8Anj/49XODxTZHwzp2ueVcfZdRNsIk2rvXz2VU3DOOC4zgnvjNTP4l0m304X2o39rp9ubh7ZZLq6iVWdWZcBgxXJ2njOR0IBBAbTQG79ub/nj/AOPUfbm/54/+PVzDeNvD8Wsf2dcapawO8MMsEstxGsdwJS4VYyW+Y/uzwPUda09V1KHSNLnvrlXdIVzsjALyHoFUEgFiSABnqRSeiuPrY1Ptzf8APH/x6j7c3/PH/wAerFm8Q6RaaTbanfala2dndBDDNdTLErlhlQCxAyR2rOl8daFbeG7fWby8jtIrqB5re3uJUSacKMlUUt8zdOAe4oem4lrsdX9ub/nj/wCPUfbm/wCeP/j1YcXiTRpN6nVLOOWO3+0zQyXCCSGPAJZ1z8oAYZJ4GRSnxHog0UawdZ08aYTgXxuk8knO3/WZ29eOvXih6bgtTb+3N/zx/wDHqPtzf88f/HqxbvxHomn6fb39/rGn2tnc48i5mukSOXIyNrE4bI547Vog5GRyKALP285x5PP+9R9ub/nj/wCPVUP+tX/dP9KfQBY+3N/zx/8AHqKr0UAMljE0LxP911Kn6GuR0eXxNpml6doEehASWYjt31N5ojaGFMAuqh/N3FRjaUADH7xAye2+zS/3P1FH2aX+5+ooWgHmlh4W1iHxc7XI1OS2i1C7vopvOtFtSJVcAABDOWw+0qxC/LkHhVrR8CeH9T0aaJtStvJC6Fp9of3it+9i83zF4J6b156HPBNd19ml/ufqKPs0v9z9RTWit6fhf/Mbd7+f+dyKipfs0v8Ac/UUfZpf7n6ikIioqX7NL/c/UUfZpf7n6igCKipfs0v9z9RR9ml/ufqKAIqKl+zS/wBz9RR9ml/ufqKAIqKl+zS/3P1FH2aX+5+ooAioqX7NL/c/UUfZpf7n6igCKipfs0v9z9RR9ml/ufqKAIqKl+zS/wBz9RR9ml/ufqKAIqKl+zS/3P1FH2aX+5+ooAioqX7NL/c/UUfZpf7n6igCKipfs0v9z9RR9ml/ufqKAK8n+qf/AHTStuKHYQGxwSMjNSvazGNgE5IPcU77NL/c/UUboDzrTNH1aHUbUWeiXmivGzfbjHqCtp0y7WDCCDzW27n2sD5cZ65OSQ2PqXhvxT/whNrotpps8cj+H4rKSSx+yF2mCMrRXDzHPlDIx5WTkucjivXfs0v9z9RR9ml/ufqKP6/P/Madnc85u/CWsahfarahVtdPls55rKQyAmO7uIvLcYHI24ds9/OOOlX/AALo+o2NzeXmqQ6nBJLBBbhNQmtGJEYb7q2yBQo3YDMSx7hQBnt/s0v9z9RR9ml/ufqKd7E20t/X9aXPO9E8L6lba5aXN7YqI4U1cbmdG2me6V48c/xJu+nQ46Vkp4O8Qf8ACPmya0mjmfQtNiLxTQkia2lZ5IfmJG5g2ASGTruOOvrX2aX+5+oo+zS/3P1FLZW/rr/mVe7b/rdP9DzjS/DOqG+0u9ura+Y/23JfXA1Ga1aVF+yPEHKwKsYJbbwu4/xE5JAjOjeIrDTreO10+dWN3qLPPYC0e6iWW5Lx7TOdgjZeWAy3CjAwa9L+zS/3P1FH2aX+5+ooeqt/XYL/ANff/meZ6Noms6Jp9lHd+HBqxn0S106W3M8ISB4t+7zCzY8tt4OUVz8p+U8VJpHhfV7bxqJLsak1rBqVzfRzedaC1xKrYAAQ3DNh9pViF+XIPCrXpH2aX+5+oo+zS/3P1FO7vzev46ieqt/W1vyIqZH90/7x/nVj7NL/AHP1FNS1mC8p3PcetIDyzWvC99dar4nRtC1y5OqTZtLm01gQWoBt40BkiFwucMpzmNiQOjdKsa9o/ie61YQw2MzQLfWVyZLMWiQXSxNEztOXPneYNjBdgAwEGTzXpv2aX+5+oo+zS/3P1FEdLeVvwG9TgdL0nV4fGKsmn3Vrp8dzczOLqS1mt18zcd9uyjz1dmbJD4UBnA/hqt4E8MatpGqW/wDaw1IjT7KS0Wa4mtPJl3OpzGsSeYVOzdmVgwzjDEk16P8AZpf7n6ij7NL/AHP1FC0sJ638zhn8Oal9p8QX9rEkd8dR+1aezuNsyfZoo2RiMlVYqy89CA2DgVzWo+G/FR8EWmjWumTxSv4fispHsTZlzMEYNFcPMc+UMjHlZOS5yOK9e+zS/wBz9RR9ml/ufqKForen4KxXM73/AK3ucFf+GLq/ttc83TY3a/vbGVUkKNvji8ndnn+Ha/B98daqa54Z1qa+1O8sUu0A1uC/hWykg86ZFtViYoJsxhg/OHAzs45wa9I+zS/3P1FH2aX+5+oo6/15f5Ex0VjnvB+mzaT4ZgtrpbhJTJLKyXMkbyIXkZ8ExKqA/N0UYHQEgZO5Uv2aX+5+oo+zS/3P1FN6gRUVL9ml/ufqKPs0v9z9RSAioqX7NL/c/UUfZpf7n6igCKipfs0v9z9RR9ml/ufqKAK4/wBa3+6P61ha1b31p4gstc07T21LybeW1mtYpESXa7IwdC5VTgpggsvByDkYPRi1m8wnZxgdx7077NL/AHP1FHW4dLHnp8P6ze65aazcWIgefVGuZLbzULW0Is5IU3kHDOWIyFLAbsAkDNZf/CN6/a6HpFpa6VdLerpFrZ3DpNaS2sjR5/d3McuW2KWY7ocsQzdwterfZpf7n6ij7NL/AHP1FNO23l+F/wDMb1X9d7nm+p+GNXn8c3Ew/tKSxvL20uxJbzWiW8XkhRh/MRpsgoSBH8rb8ErljWppem6xZ+DtV06O2e3vZL67FvKXQqUmnZlmXDdFWTODhsqRjpntPs0v9z9RR9ml/ufqKX2eX+v60C7vf0/C/wDmebXHgjVNLims9NurrVrSaG2crdG3jw1rKjLDhEQYkjyuSD90bjihNI1mXV7vXT4eltwNWhvV04zwGa5RbYxEkhzGHDMGALY+Qc5r0n7NL/c/UUfZpf7n6ijX+v6/r1F0t/W1jznwt4c1S38TW+pX2kLp8X/EyfyxLG5hM88Tp90nkqrE44ByM9M5+geDtXtbO4tdVs9RvRa6VPYBLq8tYoLvewysZhTzcNtzulIZS3Qkkj1b7NL/AHP1FH2aX+5+ooWiSXRW/P8AzHd3b87nnEGka5Pourfb9N1G48x7Y24upbKLUC0bbtweEeSwQhWQSHkhg3BFdF4PtdSttMuTq8Ukcs108ifaEgW4ZSAMzeR+7L5B5X+HbnnNdL9ml/ufqKPs0v8Ac/UU77/1/WxNtLFeT7o/3h/Osfxlp9zq3gjWtPsI/Nubqxliij3BdzMhAGSQBz61vPazFeE7juPWnfZpf7n6ikUnZ3OEh8Jz6J4v0/UbBL3VLN4WgkivtRkuDYSY4nj85zwRlGAy2CMcbgeYufDXivUba6jn0q4jP9hXlgltmzitYpZBHtW3Ebb/ACzsI/enI46c17F9ml/ufqKPs0v9z9RR1/r+uoo+7t5fgec+JdImspNa1CVLa205LLTivnzxwxSmCd3eIliAuVKqC2F+YDOM1kwxXniy3v8AXNAguYIxrkN2i2E1q8s6rbCJijsWgZgxz95h8hG4MOPXPs0v9z9RR9ml/ufqKOt/63T/AEBaK39bWOe8H6bNpPhmC2uluElMksrJcyRvIheRnwTEqoD83RRgdASBk7lS/Zpf7n6ij7NL/c/UU3qBFRUv2aX+5+oo+zS/3P1FICvJ/qn/AN00k6l7eRVGSykAfhU72sxjYBOSD3FO+zS/3P1FJq6sNOzueYW3w9mtvBPh6NE1I6paS6e9xbyaxO8KeXLG0v7tpTFgBWwAMcfL2qK4lHgpdO1DX0tQv2rVEFrPfW8LET3BkSVTI6q3yjBAO4CTp1FeqfZpf7n6ij7NL/c/UVUm3f8ArcL/ANff/meR6b4U1S48Gaj5emBJrzwrbWVqhKowlAmJj+bBXG+PqAOnpx2/iLR73W102yhup7GCOYXM91B5bOrR4KKA4YHLkNkqR8nYkV0v2aX+5+oo+zS/3P1FDd2L+vwS/Q86tND1nQbq0b7Bc65baa11bwqZLdZJo5/LdZcEog2kPGR8vB+UEcVlx+GNd07wk1p/wjwv5r3QBpv2SOeEJZyKZDhizDKN5i8rk/IOOmPWfs0v9z9RR9ml/ufqKlq6t/X9ajTa/rzuebSeEdWk8L+JLZYWguru8tbiDy5I98yRRW+VBbKgkxOo3jbnqMGkj0HVotGa6ax12S9k1U3it9rsBewHyfK8wIEFucjKlCTw27O7gelfZpf7n6ij7NL/AHP1FU227/10/wAhLRWPNrvR9dTQtJI0y+F/FDcRtLpT2SSRrI4OyWKUeS24BS5To6nbwc13Gkwz22i2UF4lvHcRwIkqWy7YlYKAQg7LnoPStH7NL/c/UUfZpf7n6ii+4u3kVz/rV/3T/Sn0420vnKNv8J7j2p/2aX+5+opDIqKl+zS/3P1FFAF+iq99Y22p2MtnfwrPbzLteNuhH9D3BHIPNZeleG2sr4XmpajPqtxCpitJLhQDbxntx1c9Gc8kADjnIBsXNxHaWstxNuEcKF32oWOAMnAAJJ9gM1x0njq/uTfz6Lo9tc2Nm20S3V5LbSSYjVz+7MBK/ewMnnGe9dhd263llPbO8sazRtGzwyGN1BGMqy4KnngjkV5rfaPquh+IU8PaXLFc2+uefLFcajdzTTR+XDGrB2bJbnpzwMDtXFjXilS/2X4rrft1Lhy39477RNbtdf01byx80JnawlgeIhsA4w6gkcjkDFOn17R7XWIdJudVsYdSnG6GzkuUWaQc8qhO49D0HY1F4e0KLw9pS2UN1e3QzuZ7y7kuGB2gYDOSQvH3RwOfWuL8VaR4mv8AxFIljptwLP8AtKyu1azFmkFykTxMxuGkPnGUbGC7AF2hBk812r4kiOjO0uPEWmQxQvFeW9wZ2QRrFcxAsGkEe4bmAIDMBxkk8AEkA6leXv4T1pbi/uBpaoNT1Oz1AqJ0/wBDSK8DvGcvjlS0vycb2l7lc9fF4+8HXU6W1t4u0OSeVhHHHHqULOzHgADdyc9qF8N+v/Df8MN6PyHt410D+3f7Ji1O1nuESZrgw3EbLaeVjcJfmyh57jsemKk/4TPwvtLf8JJpG1ZxbE/bosCY/wDLP733+D8vXiuDPhfX5bGx0w+HijaXod9p7ag1xDi7kkRVUoA27DlSxLhSCefWtjW/CN1cW2uCy0yHzLjwuum223y1JkAl/dg54HzJ6Dp6Uf1+f+X4/e7a2/rp/nf5fd18+vaPa6xDpNzqtjDqU43Q2clyizSDnlUJ3Hoeg7Gr/SvMfEGj+KLrVFjg064W1W+sbovafY1guFiaFna4eQ+cZR5bAbMLtVBk811a+O/Bt84s4PFuhyzTnykji1KEuzNwAAGyTk0P4dNyV3ZJofjCz129W3htLu2E8BubOW4VAt7AGAMse1iQPmThwrYYHFb9cL4U0XWY9T0T+1tPayj8P6ZJp4lMyOt47GICSPaxITbDn5wrZYDHBruqbt0/rX/IOoUUUUgCiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigCM/8fCf7jfzFSVGf+PhP9xv5ipKACiiigCPzl9H/AO/bf4Uecvo//ftv8KkooAj85fR/+/bf4Uecvo//AH7b/CpKKAI/OX0f/v23+FHnL6P/AN+2/wAKkrm0+IHhqS3lnjv5Hhh2+bItpMVj3HC7js4yeBnrQJtLc6Dzl9H/AO/bf4Uecvo//ftv8Kg0zVbLWbBL3TZxPbuSA4UjkHBBBAI/Gsi88d6DYahd2lzLfb7Fwl1LHplzJDAdof55ljMagKwJJbABycUD3N7zl9H/AO/bf4Uecvo//ftv8KejrJGrxsHRgCrKcgj1FVrTUrS+uLyC1l8ySxmEFwu0jY5RXxyOfldTkZHNAE3nL6P/AN+2/wAKPOX0f/v23+FSVnrrunN4ifQhcf8AEyjthdtDsbiIsVDbsbeoPGc+1AFzzl9H/wC/bf4Uecvo/wD37b/CsTT/ABv4e1WfTobDUPOfVPP+yAQyAS+SdsnJXAwfXGe2ac/jXQUgu5VvHl+x3psJY4LaWWQ3AAYxoiqWkIBz8oPAJ7HB/X6AbPnL6P8A9+2/wo85fR/+/bf4ViP420FNPtbtLmedbtnWGG3spppyUOHBhRDIu08NlRtJAOCRWppup2er6bFqGnTia2mXKvgqRg4IIOCpBBBBAIIIIBFAE/nL6P8A9+2/wo85fR/+/bf4VSfXtOjEZadisihwywuVVScBmIGFB7FsA1JNrFjb3n2aWVhJuVWIiYorN0DOBtUnI4JB5HqKALPnL6P/AN+2/wAKPOX0f/v23+FSUyeaO2t5J5m2xxqXdsZwAMmgBPOX0f8A79t/hR5y+j/9+2/wpk15BBaC5lk2wnbhtpP3iAOOvUip6AI/OX0f/v23+FHnL6P/AN+2/wAKkooAj85fR/8Av23+FHnL6P8A9+2/womuIoDGJW2+a4jTgnLHt+lMur2CyjeS5ZkjjjaRnEbEKq9eQOvPTqfwoAf5y+j/APftv8KPOX0f/v23+FSA5AI6UUAR+cvo/wD37b/Cjzl9H/79t/hTLi8t7WSCOeUI9w/lxKerNjOPyFV5tbsLe5aCWVwysEd1hdo0Y4wGcDap5HBI6j1oAt+cvo//AH7b/Cjzl9H/AO/bf4UR3EUs0sSNl4SA6kEEZGR+Hv8A4VJQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUAR+cvo//AH7b/Cjzl9H/AO/bf4VJRQBH5y+j/wDftv8ACjzl9H/79t/hUlFAEfnL6P8A9+2/wo85fR/+/bf4VJRQBH5y+j/9+2/wo85fR/8Av23+FSUUARBw9wuA3CN1UjuPWpajP/Hwn+438xUlABRRRQAUVH58P/PVP++hR58P/PVP++hQBHfWi39jLbNNPAJFx5tvKY5EPYqw6H9PXI4rL0rTNZF8LnX9TW4Nupit4rUNFHIO8sq93P8Ad+6vbk5Gx58P/PVP++hR58P/AD1T/voUASV8+i40m10J3A090ks9Olnt4telDTN5rFwYwMb8feX/AJZ8MMk17958P/PVP++hVdrbTXcs8NozMcklFJJqk7ESjzHM/C2aG48GGa2iEML3k5jiEhk2LvOF3HlsDjJ61Us9aGgeIPFkV1pWsXE13qCzWqW+lXEkdwPssKACUIYxllK5ZgBjkgc120P2S3QrB5MSk5ITAGfwp/nw/wDPVP8AvoVL1v5q35f5Fx0VjxnxZoOoWvhex0p9EW51Sy0NI7W9OmXOo/vwGzHAYzttnUhT5zHLZXghOLl3pNvaz+I/M8KmUahrEFxLLLpM1xF5RtVIkeGIA3IEocGPPyu+9tvU+tefD/z1T/voUefD/wA9U/76FO97vv8A53/T+mO/9fK39f5aHL/DSG6tvBMVvfW727xXVyqRtavbKIvPcx7InJZE2Fdqk8DA7Vg+KdP1ZPHeo6npVjdSSNY2dnHNFEf+WrXMbENg8IzxSN6Bcmuv1Xwz4W126W51vRNH1G4VAiy3lpFK4Uc4ywJxyePerunWelaPYpZaRbWdjaoSUgtY1iRcnJwq4AyeaL31Ytk0uv8Anc8og0XU9JfT7210W9kOkDVriKGO3bcw/tCN1jXj70kQfaO4PHFXrCTUPBtjqbPoV1e6jcasnkXI06a4SF2soRLcERIXK7hIPlHzH5crkkep+fD/AM9U/wC+hR58P/PVP++hRd2t/W9/+AN6u/8AX9I86e2srWx0y9hXxLG5NyX1y006b7Wk0jq0ivaNCxMcmDgmMquxcYO01uaNFfv4AvlmgZJ5ftLRM1qLeW4RmYrLJGANsjg7mGFOTyqngdT58P8Az1T/AL6FHnw/89U/76FLpb+v6/rzF1MTWZ0u9K+yW63m2aENCbe33xzgjhGYA7V6ZyV4PXrUc9z9p1H7FcWlza26yI8xis5W+0ycH76qQEBAyScnGOAOd2N7aKMJE0SIOiqQAKd58P8Az1T/AL6FHW4uljF8SxiZraOSyW4TDnzJbWS5RG4wDEnc84Y9MH1rHuLR5dFi/tXT7m6kOlrFbqIGd45wDv8AUox+T5jjp1rsvPh/56p/30KPPh/56p/30KVtLFXOQv7HcH+1adPPeM9sbWVIGby4xs3DcBhcEOSDjOe9Pm0qRdFLraBWk1GR7oPaNMZYxJJs3RghnUEqcDtzXWefD/z1T/voUefD/wA9U/76FN6iWiscjcWJ/saxjuYZJgiy+Wk2lvLGAT8qmJWLIQMBSTwMg4PFS6rbySS2sj2Ej3K28YWGW3edQ4OcJMrfumzwXbr8p7Gup8+H/nqn/fQo8+H/AJ6p/wB9CgDM8QwpNa2ouLaS5gW5RpY44zJ8uDnKgEkeo79K5+70ue4sJY0sJDA1leC3iaI/IC6GNcEfKeMheox7V2fnw/8APVP++hR58P8Az1T/AL6FC0Hc5cW0Y123ltLByd8WxZbB0MSBQPkmBARQM5jYZJ3DHNdOwh+2IWjzNsbbJ5ZOFyMjdjAzxxnnHtS+fD/z1T/voUefD/z1T/voUEnO6pZ6q+vWt0LWCeNbpBEwmbMce05yuwgZPJOeyiknlvLDT7uwhtTJcvPK6CSyeeK5V2JALKQq9QCWPGOmMGuj8+H/AJ6p/wB9Cjz4f+eqf99ChaK39f1oPrcoQbn8RuwABWzRZsdAxYlR+Hzfn71p1Cj20bOUaJS53MQQNxxjJ9eAPyp3nw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQBJRUfnw/89U/76FHnw/89U/76FAElFR+fD/z1T/voUefD/z1T/voUASUVH58P/PVP++hR58P/PVP++hQAH/j4T/cb+YqSohIj3C7GVsI2cHPcVLQAUUUUAFFFFABRRRQAUUUUAFFFeTQXvxNWwulvItV+3Dyxb+TDZGLO795uOM42/dx3600rkuVj1misLwbNrc/huI+J0dNREjh96KrFdx2khfl+7jpXC6jqu34g63CviC+TV4dVsY9M0tbxwjxtFCZgIc7ZFKlyxIOz7w2k5Ivit/X9aldLnq9FeVRztH4cXUNX1nUILC88Q3Nvqd4+pyxi2t45rhYlVgw8lS6xIWXaSDgnHQXVY5NP0hfE+vXdh4cc3wg1I6g9qZ9koFruuFcM2YS7Lk/vMBjk0v6/C42rO39dV+n5HqtFeQz6xqh8f20MWrhW82xGnpf6lcW811bMimVjYpDtlLEygu20oVydgWtLRNYX/hZcsA1Z9Rlknulkjt9Umd4EGSqz2DpthVcBFkQgudh58w0/wDg/gL/AIH4no9zcwWdrLc3k0cEEKl5JZXCqijkkk8AD1qUHIyORXittr0yeGfFH2HXJtQuY9Dmna/stZmuVWVc4eSF1BspTkkRI2OGGPkFa95Nerq2raqNU1HzrPxHp9nBCL2QQLFItqJFMQOxs+a33gcHkYNNK7S7/wCdv1B6fj+SZ6nRXl0Wpxt42sUm1y9XXG16aG60xb2Ty0tQkvlZgztVCixMHwNxPU5xXoHiCVoPDWpSx3jWLrayFbpITKYDtOH2Dlsdce1Rf3eYdvf5f63t+ho0V5ToetOnhvWL3T7yW8j0ma3vHks9dl1W2kReZkSZ1DltgYtESwBKEcsag8Qahc6Vcab/AGlrUpvvssc/9nLrE1ncec8rO32dNrJeE5CCJ+FCKON9VbW39bE30uesQ3VvcSTRwTxyvA/lzKjgmNsBtrAdDhgcHsR61LXjOrzNpGo+Kfsd6bcTeIrdtR+1azPaLFbNaqysZV3NArSgJvVRkDZkKPl2dIjvNdt/DNlqWsXT201vfv5mm6lcL58aSIISZ8RySYUj58DfjOSGOV9m/p+Vyno7f1/X/APR7y8tdPs5bu/uYbW2hXdJNPIERB6ljwBVHSfE2g6/JKmha3p2pvCAZFs7uOYoD0J2k4rivB0t5Bq3heWfVNQvH1fR7ia8+1XTyK7xmDYyoTsQgOw+UDOcnJ5ro/BCm+0248RT4a41qUzq2c7LcErAg9AEwxH953Penb+vnYWtjd1DUbLSbGS91S8t7K0ix5k9zKscaZOBlmIA5IH41LBcQ3VvHcWsqTQyqHjkjYMrqRkEEcEEd65rxpc2+n3Xh7UdSljg0201Pfczy8Rw5glRHdjwq72UZPGWFO+HysPCrSAFbee/vJ7QHvA9xI0ZH+yVII9iKS1TB6W/rv8A5fidHP8A8e8n+4f5VTvNf0fTtQgsNQ1axtby4x5NtPcokkuTgbVJycngY71cn/495P8AcP8AKvOvE91p9jqHiG3Gp2ME1+oN1pGrxfNqOIVVfsro6v8AMBsyBJhxwoIIbtweHjiKjjK+3T1S8/66rcT0R6TULXdss8kLXEQljjErxlxuVCSAxHYZU89OD6Utsxa0hZo2jJRSUc5K8dCfWvPo73UrPxEniy+is4dFubtoGu3vG3rbOFjiJjMYVVMiI+7ecCQ8cmpw+GdZyV9tvN9F8/IXNpc7qTV9NhtY7mXULVLeWMzRytOoR0C7iwOcFQvOemOauA5GRyK8l1WRLfw14hkuomhttT0a7fRRIf8AVxYd3jwfuswKyBeu35cfu69Xh/1Ef+6P5VpisKqEU073b/C3+dn5pgpX/r0/zIjqNkLKW8N5b/ZYd/mz+auyPYSH3NnA2kEHPTBzVC68W+HLHUDY3uv6Xb3gIBt5r2NJATggbSc85GPrXnt3b683wt8VSW2padHp/masTbyafI8pXz5tw8wTAZPODs49D31rTSdW1rUPF9jaanZ2lhdXawXCSWLTSkNZwBir+aqr8p4yjYPPPSuv6hQhzOdTRNrr0cV2ffp94nJ3t5v8DuJNW06HVItMmv7WO/mQvFaNMolkUZ+ZUzkjg8gdjVuvNNTMFtqGp6Isg/tefWNOnsYmP72WBBbgyL3ZVEcu4jgYbPXn0uuHE4dUYwknv/knf01t8mNNt2YUUUVxlBUcP+rP++3/AKEakqOH/Vn/AH2/9CNADY7u2medYbiKRrd9kwVwTE20NhvQ4IOD2INZV5418K6cYRqHibR7U3ESzQ+ffxJ5kbdHXLcqexHBrl7C38QzeIfGjaLqmmWluNSAeO702S4ct9kgyQyzxgDGONp+vasPwFb65cTWY0LUtPsSPCukiU3lg9zu/wBfjbtmj24565zx0xyK7jfyX4pspq1/66pfqeoXGu6RZyWUd3qllA+oHFmstwim5PHEYJ+fqOmeoq/Xkev2Fj4W07WPD88++a68NQ2Oj+aAJLuZDMCkfQF97xnavIBXsOPWIBIttGJjmQIA59Tjmnp0Jejt/XT/AD/AyofGHhm41b+yoPEWky6j5hi+xpfRmbeOq7A2cjB4x2ouvGHhmx1T+zL3xFpNvf7lT7JLfRpLubG0bC2cnIwMc5rz2HX9Dm+HWueHxqFnca5Lf6iltpkc6NdGc3cpiIj5YENtfdj5QN3QZrR0/wASeHdJ1LxnpvijVNPE898u+wmlQy3SmzgUhYj8z7iCAADk8Cp6X8r+u3+ZTWtvOx2eq+LfDmhXS22t+INL064ZA6xXl7HE5U8ZwxBxwefatK2uYL21iubOaO4t5kDxSxOGR1IyGBHBBHcV5Votr4yttSuE0e40+LV7fw1pwmt9Utnm82QG4whdJE2HIIJw36c9n8O3sn8E2psJpJCZJWuVlQI8Nw0jNLGUBOza7MNuTgAcnqbas2uxL3/rsmdEt1bvdyWqTxtcRorvCHBdFYkKSOoB2tg98H0qnqPiHRdIu7e11bV7CxuLo4ghublI3lOcfKGILckDiuWm8R6J4f8AirrP9vazp+medpVl5X226SHzMSXOdu4jOMjp6iol1zw5pep+JB4nu7Uf2s6yW3n4YahaGBFVIf8AnsM7xsXJy/T5wTPn/Xp/XYbVnb0/Ff0vuO1n1OwtYbqW5vbeGOzXdcvJKqiAYzlyT8oxzz2p5v7RWCtdQAtEZwDIOYxjL/7oyOenIry600+6tv8AhH9E1SOZZNesLWOaKQ5ZPsrmR1c92MbKh/3e9MhtZr3RL+S5imuYNFls9JuY0jMjSw28++c7MEsGQoWUZ3BSMHoX1+f/AAL+l7fiL+v+AvPc9M0nXtI16B5tC1Wy1KKNtjyWdwkyq2M4JUnBxUdj4l0LU7+ex03WtOu7u23Ge3t7tJJIsHB3KDlcHg571wviK8tvFmoXVx4Euo9RmTQruC5vNOlV1bdtMUHmLwZM7yBnKgk8bhnTi13wXqv9j6fowhvLuyVvs1rZYEmmKIirecoIMKgfIVYDkgbSRxMnZX/rr/X9XBf1+H9f1Y6xNc0mSwt76PVLJrS6kWK3uBcIY5nY7VVWzhiTwAOpq9XgmlFj4Q8L6SVbydPl0nUVypwDPNAqEHP977Vx9Pave60lG1/Vr8gIx/x8P/uL/M1XvdX03Tbi1g1HULW0mvH8u2jnmVGnf+6gJyx5HA9asD/j4f8A3F/ma4rxhb3f9o6rHHBdTHVtHFhYNBbPKsVxukyXKgiMHfGdzED5OvFR1SH0/r+vM7msyPxNoMulT6nFrenPp9s5Se7W7jMUTDGQz5wDyOCe4ritRfxDqGparpVvqWtm3uIr2GzaTTFjiM3kqAjSeSCsSliUk3DedwyQoLrIZ7jWbbX7ay1GLSbF7RLi1bT5llYxpcqxWLZvcKZoeVUg7DjOKPP0/r+vwDp9/wDw3z/TudxLr2jwCxM+q2MY1EgWW+5QfaicY8vJ+fOR0z1FPj1fTZdWl0uLULV9QhQSS2izKZkQ4wxTOQORyR3rziSw1KCx1RJbW+dtcsZ4NMVLORvszyXNxIgkAXEPyywnL7QNhHUYrY0y1vV16z0+SG6+1WesXd/cXLWziGS3kWYIBKRsY/vIhtBJGzkDFNf5/wBfr/VxPT+vLf8AReZ2d9f2el2Ml5qd3BZ2sQzJPcSCNEGccscAcmoJde0eAWJn1WxjGokCy33KD7UTjHl5Pz5yOmeorP8AFayxrpN8sc8ttYX6z3UdvC8rtH5ciAhEBZsO6NgAniuLksNSgsdUSW1vnbXLGeDTFSzkb7M8lzcSIJAFxD8ssJy+0DYR1GKS1f8AXb9f6vsNr+vnb8N2ejx6vpsurS6XFqFq+oQoJJbRZ1MqIcYYpnIHI5I70um6vpus27z6RqFrfwo5jeS1mWVVcdVJUkAjPSvPdQ0rV721uNDs0uo9UjvNQumu2t3WJopop1ixMRsJzLENoJI2cgYrpfDDNe61e6jBbXVpZGytbVYrq1kgbzYzKXIVwCQA6DdjBxwTihar+v68v8hPT+v6339O51FFFFAEc3+rH++v/oQpzyJFG0krKiKCzMxwAB1JNNm/1Y/31/8AQhWd4oiW48I6tC9y9ostnLG1wkDTNEChG4IvLYznApSbSuhxSbSY/SPEmh+IPN/sHWdP1Pyceb9iukm8vOcbtpOM4PX0NSXGuaTaaZJqN3qllBYxOY5LqW4RYkYNsKlycAhhtxnrxXKeGHg1lL3R7fxLJ4m0UWkam/guIkaKQkgxLJahMfKFOPvDPJwRWDpur+HfBngKwlv4bWNrbXL+HSYJJxbwpL9onQZYkKiqhbLHOB0BbANOy/rzt/wwldr+u1z0mDW9KuWs1ttTs5mv0aS0EdwjG4QDJaPB+YAEZIzU9tfWl6062d1DcNbymGYRSBjE4AJRsdGwQcHnkV49PLYaXq2i69Z6naapHZWuo6pc3OmsHhy1zbmcR7TyAjyADJJxk8muu+GNvLbf8JKlyNtw+qJLOP8Apq9pbu//AI8xoSur+X62B6f1/Xkd1RRRSAKKjuYnntZYop5LZ5EKrNEFLxkjAZdwK5HUZBHqDXNeEdL8W2ElwvizX11RY3KwultFF5q9nIVRt+meueSMEgHSz/8AHvJ/uH+VSVHP/wAe8n+4f5VR8R2l1qHhfVLPT32XdxZyxQNnGHZCFOfqRSbsrjirtIn03V9N1m3efSNQtb+FHMbyWsyyqrjqpKkgEZ6VYeWONkWSRUMjbUDNjccE4HqcAn8DXns1zqMs8upaCurWAdbCzht/7MdfNlR5TIkgkiJSHa6gzAADblS2NpjknWVvAuo39prGoajFeSNNe3GhyLPAjQyoyv5cQEa+Y0YwcAgBssAWqra2J6X8v6/y9Tsx4q8PHVJtNGvaYb+AMZbX7ZH5sYUZYsmcjA5ORwKhTxv4Ul0+W+j8T6M9nC6pLcLqERjjZvuqzbsAnBwD1xXN6RpssnxE8Sa3cT6olnaTkx2MljIsUzG2gTz4ztBkYeVKnG/g8Yz83O6foV7p3wftWnudcmvry403C/2bIbnT0ikh3RiLyz8qGORwWTBzzuJyyWqXy/F/1/Whdlf+v60/ruetWN/Z6nZR3mm3UF5azDMc9vIJEcZxkMODyKojxV4eOqTaaNe0w38AYy2v2yPzYwoyxZM5GBycjgVL4f0ptE8P2enyXL3ksEQWW5kBDTyfxSNknlmyx5PJrkNI02WT4ieJNbuJ9USztJyY7GSxkWKZjbQJ58Z2gyMPKlTjfweMZ+Ylo3bsxLVf1/X9dTpE8b+FJdPlvo/E+jPZwuqS3C6hEY42b7qs27AJwcA9cUsvjTwtBHayT+JdHiS8XdbM9/EBOM4yhLfMM8cd6840/Qr3Tvg/atPc65NfXlxpuF/s2Q3OnpFJDujEXln5UMcjgsmDnncTltbUvCty2u+FNDXUtUxbWM322/js3aO8Jlt3dJpMEL5oikJG8HJ5yDtauVc1vO34Xf8AX3XDTv8A1/X9I9MooAwAB0FFSIjP/Hwn+438xUlRn/j4T/cb+YqSgAooooAKKj8iH/nkn/fIo8iH/nkn/fIoAkoqPyIf+eSf98ijyIf+eSf98igCSio/Ih/55J/3yKPIh/55J/3yKAJKKj8iH/nkn/fIo8iH/nkn/fIoAkqra6baWV5eXVtFsmvpFluG3E72VFQHBOB8qqOMdKm8iH/nkn/fIo8iH/nkn/fIoAkoqPyIf+eSf98ijyIf+eSf98igCSio/Ih/55J/3yKPIh/55J/3yKAJKKj8iH/nkn/fIo8iH/nkn/fIoAx5fCGkz6jJfT/2hJO+/aX1O5KwlgVLRKZNsTYJAZApAJAIzRYeEdN06+ju7e51l5IySq3Gt3k6HjHKSSlW69wa2PIh/wCeSf8AfIo8iH/nkn/fIo2Dcg1LTLXVrM2t+rvAWDMiSugfBzhtpG5T3U8EcEEVbqPyIf8Ankn/AHyKPIh/55J/3yKAJKKj8iH/AJ5J/wB8ijyIf+eSf98igCSqOq6RbazbLBeSXkaK+8GzvprVs4xy0TqSOehOKteRD/zyT/vkUeRD/wA8k/75FAFDSNAs9EaVrObUZDKAG+26ncXWMenmu23r2xmtOo/Ih/55J/3yKPIh/wCeSf8AfIoAJ/8Aj3k/3D/KpKj8iH/nkn/fIo8iH/nkn/fIoAx7jwhptzcSTyXOsh5GLsI9cvI1BJzwqygKPYAAVtqoVQozgDHJyfzpnkQ/88k/75FHkQ/88k/75FaTq1KiSnJu3distySsO48Iabc3Ek8lzrIeRi7CPXLyNQSc8KsoCj2AAFbHkQ/88k/75FHkQ/8APJP++RRTq1KbvCTXo7D3HqoVQozgDHJyfzpaj8iH/nkn/fIo8iH/AJ5J/wB8iswJKKj8iH/nkn/fIo8iH/nkn/fIoAkoqPyIf+eSf98ijyIf+eSf98igCSo4f9Wf99v/AEI0eRD/AM8k/wC+RR5EP/PJP++RQBJRUfkQ/wDPJP8AvkUeRD/zyT/vkUASVz9x4K0u5upJ5LrXFeRy7CPX76NQSc8KswVR7AACtzyIf+eSf98ijyIf+eSf98igB6qFUKM4Axycn86Wo/Ih/wCeSf8AfIo8iH/nkn/fIoAkrI1XwzY6xdLcXc+qRuqBALPVrq1TH+7FIqk89cZrT8iH/nkn/fIo8iH/AJ5J/wB8igCHTtPh0uxS0tnuXjQkhrq6kuH5OeXkZmP4nirVR+RD/wA8k/75FHkQ/wDPJP8AvkUASUVH5EP/ADyT/vkUeRD/AM8k/wC+RQBJRUfkQ/8APJP++RR5EP8AzyT/AL5FAElFR+RD/wA8k/75FHkQ/wDPJP8AvkUAA/4+H/3F/makqPyIf+eSf98ijyIf+eSf98igCSio/Ih/55J/3yKPIh/55J/3yKAJKjuLeG7tpba7hjngmQpJFIoZXUjBUg8EEdqPIh/55J/3yKPIh/55J/3yKAMzSvCXhzQrprnRNA0vTbhkKNLZ2UcTlSQdpKgHGQOPateo/Ih/55J/3yKPIh/55J/3yKAJKKj8iH/nkn/fIo8iH/nkn/fIoAkoqPyIf+eSf98ijyIf+eSf98igAm/1Y/31/wDQhUlR+RD/AM8k/wC+RR5EP/PJP++RQBJRUfkQ/wDPJP8AvkUeRD/zyT/vkUASUVH5EP8AzyT/AL5FHkQ/88k/75FAElFR+RD/AM8k/wC+RR5EP/PJP++RQBJRUfkQ/wDPJP8AvkUeRD/zyT/vkUAE/wDx7yf7h/lUlR+RD/zyT/vkUeRD/wA8k/75FAElFR+RD/zyT/vkUeRD/wA8k/75FAElFR+RD/zyT/vkUeRD/wA8k/75FAGbqvhTw7r1ytzrmgaXqU6JsWW8s45mVck7QWBOMk8e9aNtbQWVrFbWcMdvbwoEiiiQKiKBgKAOAAOwpfIh/wCeSf8AfIo8iH/nkn/fIoAkoqPyIf8Ankn/AHyKPIh/55J/3yKAJKKj8iH/AJ5J/wB8ijyIf+eSf98igAP/AB8J/uN/MVJUQjRLhdiquUbOBjuKloAKKKKACiiigCvfC8NjL/ZrQLd7f3RuFLR59GwQcHpkdOuD0rL0rVdX1W+Hm6W2mWkClbgXQzJLL/diwcFB13nO7OAByRuUUAFfP0GnW9vodx5t1iO6t9PneeXRZ2a3DykNsfOAAB97pJ91eRX0DXJS/DXQ5YWgabVPIZEj8n+0ZSgRDlEwW+6pJwO1VF2M5xchvwyKf8IaEhuDcwxXc6RSlCm9Q5wQp5XPXHbNZFt4b8MalrXjfUvEemafI9tqAzfzwqJbdFs4G3LLjcm3lgQRg8jmu00HQbLw5pgsNMEgtw7OBI5Ygscnk89aguvB/hm+1T+073w7pNxf7lf7XLYxvLuXG07yucjAwc8YqXq35q35f5GkdFY8+1bxV4gs/BdrewX+pnUrHQor+7tbW0t8KSrESXLTnOxvLI2RYcYY85XE1rc3llqXij7Nrmoi41HXo47eG0treSaQ/Y45CkJdQinaMbpNy7Y/7x3H0LU/Dmia1cQz6zo2n6hNACIpLq1SVoweoUsDj8KbdeF9AvknS90PTbhbkRidZrSNxKI/ubsjnb2z07U76t9/80/0/rYfS39bf1/WpQ8Bavea14TS51NpWuo7m5t3M6xrJ+6meMbxGdm/CjO35c5xxWH4r0GHXvF0w+w6P4ilhsI1bSdYZohbKzyfv4X8uQAtjacLn5F+YYwd+bwqY9keg6zeeHrRFwLPS7azWLOeWxJA5yfY446VJL4S0rUrG3t/E9vB4kktyxjuNWs7eR13HnAWNVHQDhR0Gc0nq7gtL/15nDXNlovifRNNgtLe41vW7zSolsm1J0kbS4+R9raRR8jlv4lO6Qou3hSVqZfT/E/i6yMzO+uXcem7ycMzLbW+SMD73lyTP1/gr0fUfBvhjWLoXOr+HNJv5wgQS3VjFKwUdBllJwPSrq6PpiSCRNOtFdZPNDCBQQ+zy92cddny567eOlD1v53/ABf9fPUFpby/r+vI8Y8N350G50zWIgNyeE9Ns1U9C0qTmMcDvJHGo/3q7bwIjaJ8K7uO2Ys9nc6iqOeTlbmUbj+Wa69dD0lEVE0uyVUWJFUW6AKsR3RAcdEJyo/hPTFTxWVrBbPbwW0UUMjOzRxoFVi5JYkDuSSSe5Jqpy5m33/r/MO3y/BWMHWtMs00l/ssVvJcWkAPmSS/vLdBlvMQc4ckE5+XJHJ4pbm0tdR1P/QozNfeZHLJduBm0QYIQHqCQD8o/vEng8666RYlLcXFvHdPbACKW4jV3QDpgkfT8qJNF0uW6NzLptm85bcZWgUtn1zjOaXW5PQra1czRyQwWs9ykrK7+VaxxmRwuOd0nygDIz3ORjvWNdahd6poUjSXv2RRpC3L7UXbMzhgwOQSANvbB+br0rqLqxtL5VW+tYblUOVE0YcKfUZpkul6fPFFHNY20kcP+rR4VIT6DHFTbRopPU5nUJp7jTpt94YIrWS1iW32rtlz5bbicbsktgYIHy9+anbUNTGnrKtzcSvdag9uqxJCDEiu4+XcAMnaB8xPXjnr0Eum2M8scs9lbySRgKjvEpKAdgSOKdJY2ktq1tLawvA5LNE0YKsSckkdOvP1qnq7krRWOfa+1WbTbbbLKsoE3mi2a3aZgrbVYhiUx/eCnIYgCnX2qXW2G7t7uT7IttHNI9vHEduTktIjndtI6BDn73tW1NpWn3FvFBcWFrLDCMRxvCrKn0BHFPm0+yuZ457izgllhx5ckkSsyYOeCRxzSGUdfVpI7BY5/s7NeIBKACV4bpnjPpkHmue1a6uLqwuoZZ95jsr1PPESBpAjoOuOMjIOMA9eOMdlcWtveReVdwRzx/3JUDD8jTRY2gjVBawhEjMSqIxhUPVQPQ4HHtQv6+4d9UzEN3e22qRCS8me1WWKDeiwvGSVAxIBh1cseq/KAV4610BRjMr+YwUKQYwBg9OemcjHr3qsmlafFcR3EdhbJNEoVJFhUMgAwADjIGOKsmKMzLKY1MiqVVyvIBxkZ9OB+VMlHL6zqDP4hsVlS7jit7xVRRbSFZSUbLbguDjgAA/3jTJ1sjp9/qGoWklxdwXMnmzQ7BNaqpJQqXYbQFCkAdc9Dk11bxRylDIiuUbcu4Z2n1Hoeagm02xubpLm4sreWePGyV4lZlwcjBIyOaS0/r0/yH/X5lW3YJ4glEWRHcWyzMvowO3P1IwP+AitOoIrVIrqa4yzSTbQSx+6o6KPbkn6k1PQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFAEZ/4+E/3G/mKkqM/8fCf7jfzFSUAFFFFAEfkr6v8A9/G/xo8lfV/+/jf41JRQBH5K+r/9/G/xo8lfV/8Av43+NSUUAR+Svq//AH8b/GjyV9X/AO/jf41JRQBH5K+r/wDfxv8AGjyV9X/7+N/jUleW2/xoW4065u/7NsIvs4iPky6rtkl3tj5F8rnb1b0FNJslyS3PTvJX1f8A7+N/jR5K+r/9/G/xrJ8JeI18VeHYtUW3+zeY7oYxJvA2sVyGwMg4z0Fc/eeK/EEHiHWDFHpv9kaTf2tq8bRv586zJESQ4bapUy5A2nd0+XqV1sUtVc7byV9X/wC/jf40eSvq/wD38b/GuGtfFPiK9tI2jfTIptR1ifTbHdaSOtusLzb5Jf3g8wlYDhRswT1I6SW3irXdXez0rTTptrqpN4Lm5nheaA/ZpViOyNZFYb2cNyx2gEHceaBtWdn/AFv/AJM7XyV9X/7+N/jR5K+r/wDfxv8AGuCn8c63F4vOmjT/ADIrSe2tbyC20y6uN7yojPIlyoEaKgkU7XXJCt93IrQ0/wATavJ42fTNUFvawPLNHBbSWFxG7BOUdLokwzFlG4xgKygnrsOQW39dzrfJX1f/AL+N/jR5K+r/APfxv8a82n8Z62fDfiI6utvBd22lTXSWJs7uylgdcgoJS2J1GQDLCy4OCB8wxfn8X69Dq17Io04aXYavaaa0JhkaeUTrD8wfeFXaZs/dbIGOOtNK7S7/AOdvzB6f18zuvJX1f/v43+NHkr6v/wB/G/xrjovE2vTazZTp/Zw0e81ebTVgML/aEEQlBkMm/aSXiPy7BgEck11epz3VtpN3Pp9t9ru4oXeC33hfNcKSq5PTJwM0ulx297l/rt+hN5K+r/8Afxv8aPJX1f8A7+N/jXEaZ4y1H+zLm41G4tJjZ3VuLgf2Xc2EscMpCsWhmJIwckSBmUhWGAVqG/8AGWv20en3jx2llYXEK3PnzabczRyK0hwjyxMRbFY9hMkispLnAAUinbWxPS53vkr6v/38b/GjyV9X/wC/jf415nN4p13RNS8RBrxLr7R4gjsrIDTri6+yIbVJWPlRyF5BtH3U2/MWY8HA1rbxN4l1WDRbeyhtNOvb2O6M8mo6fOoHkuqh1hZkcK4bIDHIDDk4wV0v6flcpqzsdt5K+r/9/G/xo8lfV/8Av43+NcNomv6xr82l2mvi1jtNf0yW5jTTmmhmtjGYgR5wcFt3mZBUIVxj5utXPAVgPM1TVre71KSxubgwWUF5qM90BFExQyDzXbBdgx442hO+cu39fOwuh1vkr6v/AN/G/wAaPJX1f/v43+NYHi0yXFzoelie5t7bUb8xXD207QuyLBLIFEiEMuWReVIOAR0JpfA95cXfh11u5nuGtL66tEmkbc0kcU7xoST1O1QCTySMnmkgen9ev+RuSxhYXZWcEKSPnb0+tO8lfV/+/jf40T/8e8n+4f5VwfiSK/8A7S1a+efVZoIdv2W60i++XTNkas3n23mIJTuJfGJCynbgYAPThqCrz5XK39W/r8LvQT0R3nkr6v8A9/G/xo8lfV/+/jf40QSCa2jkVxIroGDqMBsjriuItvEzXHxAkhdr77DcSyaag+zzrACi7hIJdvl7i4mT5Wyfk9KKOGnW5uX7KuLmSVzt/JX1f/v43+NHkr6v/wB/G/xrzW/1S9Ph/wASRLql0p0TS7pbKZJnV7rG9fOLZyxjKbM/3gzfxKa9LiJMKE8naKrEYV0Em3v/AMB/k/lsCf8AX3CeSvq//fxv8aPJX1f/AL+N/jXmd34m1qH4deJTFpeszPDJqaxapHcwBYgs0oUgtMJAEAA4XI28A8UXUeqaprXiaOytPEF3dxXCRWVza6wYLa1Y2sTLujM65Adix/dtnPfpXZHLHd880kr9V0cV3Vvi9fIHK2nr+B6Z5K+r/wDfxv8AGjyV9X/7+N/jXBahdahFc6hqsl9ci803VbGxjhSdlheOT7OJAYgdrFvOchmBYfLjGBXoNcNbDulGMr3v/kn+TQJ3I/JX1f8A7+N/jR5K+r/9/G/xqSiuYoj8lfV/+/jf402KMMhJZ/vMPvt6n3qao4f9Wf8Afb/0I0AHkr6v/wB/G/xo8lfV/wDv43+NcLaeI9Wtde8W28Wh6xrEUOoBYpbae2CQD7LCdgEsyMOSW4GPm9c1y2iXOoaxJp4vLTxRrZ/4RrTZ8aZrbWuyR/N3PJm5i3M20c/Mfl7dzpf0/FN/oO1r/wBdUv1PY/JX1f8A7+N/jR5K+r/9/G/xry/Um1220XUW1jVbuLU/Dnh2G8iaC6ZUe5PnFmkCkCYfuVXDgr97A5r1CCQy20cjrtZ0DFfQkdKbVhf1+X+YeSvq/wD38b/GjyV9X/7+N/jXmUFq8fgbW/FQ1bVk1SxutRmid9UuGh/c3EoSMwM5jKlUCY2dDxg4NaOm6UPEWseKLq/1PWLSa2vkjtzb6rcRJaj7LC/EQcRnDMxwykHuCOKno2+iv+Q7a287fcd55K+r/wDfxv8AGjyV9X/7+N/jXjza/c6pdnVdZ07xNqUCeHrK9ki0HUntlhZjMXfyxPEWLBRjAY4Xt39G8EG7fwZp8l/dfamlQyRSmYTMYWYtEGkH32EZUFsnJBOTnJtxtfyE9Hb+tk/1NvyV9X/7+N/jR5K+r/8Afxv8awLC6uH+JetWrzyNbx6ZZOkJclEZpLgMQOgJ2rk98D0qgNNfxPrGvSX2qalZHTroWtmtlfSQLABDHJ5jIpCyMWfOJAy4CjGM5n/hxvR29PxVzrvJX1f/AL+N/jR5K+r/APfxv8a8xttb1bVtKhtp7+WK48Q2Fi0E0MjIVYuUuHiwQUHlhXGMctTxrur3tlGyX01u8UNjpVzKrkeXcS3Hlzvzld4CrtY5wX/Au1387fP/AIe33ien5/1/XQ9L8lfV/wDv43+NHkr6v/38b/GvP/EE914EnnGhX15cRzaReXJt9QvJbvyZIQhWYPKzMF+fDLnaflwAc51l8Px6K9lfQeJtQE8mUn+3X7zx35ZCcLG77I3yNw8oLgAjG3gS3ZXHbodV5K+r/wDfxv8AGjyV9X/7+N/jXi+m+IdXk8CeE7N9VvGvY76xuLq5Nwxknikktzsdt24g/acc8HyyK9sq3G332/IRCIx5zLufAUEfO3qff2p3kr6v/wB/G/xoH/Hw/wDuL/M1xXjC4u/7R1WSOe6hOk6OL+wWC5eJZbjdJkOFIEgGyMbWBHz9OanrYdtP69DtfJX1f/v43+NHkr6v/wB/G/xri9V8Ya7BJrFjbaRZrc2VrczpIt+XJVYlaIhPKwXLMA0eflGCSQ6bqEgnt9ZttAtr3UZdJvntHuLptQmaVTIlyzBZd+9Axhh4VgBvOMZo1f4fiLZX9fw/4c9D8lfV/wDv43+NHkr6v/38b/GvMJL/AFKex1R5bq+RtDsZ59MZLyRftLx3NxGhkIbE3yxQjD7gd5PU5rY0y6vW16z1CSa6+1XmsXdhcWzXLmGO3jWYoRETsU/u4juABO/knNNa/wBfL+v89Aem/wDWl/y+87fyV9X/AO/jf40eSvq//fxv8axPFbSyLpNisk8Vtf36wXUlvM8TrH5cjgB0IZcuiLkEHmuLkv8AUp7HVHlur5G0Oxnn0xkvJF+0vHc3EaGQhsTfLFCMPuB3k9Tmktf68rjt/Xq7Hp/kr6v/AN/G/wAaPJX1f/v43+Nebahqur2Vrca5ZvdSapJeahataNcO0SxQxTtFiEnYDmKI7gATv5JzXS+GFay1q906C5uruyFla3Sy3V1JO3myGUOAzkkAhEO3OBngDNC1X9df6/yE9Px/B2/P8NTpPJX1f/v43+NHkr6v/wB/G/xqSigCGWMKgIZ/vKPvt6j3p3kr6v8A9/G/xom/1Y/31/8AQhVPxB9v/wCEb1L+x42k1A2sotUVwhaXado3EgDnHJNJuyuNK7sXPJX1f/v43+NHkr6v/wB/G/xrivDFrqmnrfaPJvsNae0jnSe51e61iHGSu7ExQq2QcquAcjk4wKWkM8vw7WXxL4lvktrTVLxby5Erx3F2q3MqRxh4irKS2zCx8nAQDBxVP+vyEtv67XPQvJX1f/v43+NHkr6v/wB/G/xryyO91rR/EnhdtRvb+GzWO8me2u7ks32driGOITkn5nRZQcsWIwcknJrofhtqF7qK+IZ7+5nm36oJYUmkLeRHJbwyLGvPAG/GBx19aErq/wDW9geh2Xkr6v8A9/G/xo8lfV/+/jf41JRSAj8lfV/+/jf40eSvq/8A38b/ABouWnW1lazjjluAhMUcshRGbHAZgGKgnqQDj0PSua8I+Jtc1+S4TWfDLaI9s5jlV7vzcP6AhAG7HI4wQe4yAdHLGFhdlZwQpI+dvT607yV9X/7+N/jRP/x7yf7h/lVHxHd3Vh4X1S809N93b2cssC4zl1QlRj6gUm7K44rmaRe8lfV/+/jf40eSvq//AH8b/GuGi1O78MT3aacsuq2EcFlcSve6jLJIpmeRZDGWEjMcLGREMZzheSAbc2p6reXHg3UJZ/sK3946T2NpcLPBKjW0zoTIY1YkbFPGFyT97ANVbWxK1V/K/wCFzrvJX1f/AL+N/jR5K+r/APfxv8a8903TtXvPitrj+def2PbzOjSf2tcHa7W0BEQg3hFX97I4dQSCB90Abub0m08RH4T/AG+9uL5bi9uNMFp/xP7sm4R3hDO024vFvMsisqgAYGA2AxS1V/T8S7a/1/X9fI9m8lfV/wDv43+NHkr6v/38b/GsrwlaX9j4T06DWDJ9uEIa4SSdpjG7fMyeYzMzBSSoJYnAHJrktN07V7z4ra4/nXn9j28zo0n9rXB2u1tAREIN4RV/eyOHUEggfdAG4lo2uyb+4lao9C8lfV/+/jf40eSvq/8A38b/ABrxnSbTxEfhP9vvbi+W4vbjTBaf8T+7JuEd4QztNuLxbzLIrKoAGBgNgMb+p6P4nMnhDTo5b4X81lK9/ENcuY/s/wC/t97AiQ+c0YlkCh2OR1LYCmuX3redvwv/AF+Nh2/r+v67XPV/JX1f/v43+NHkr6v/AN/G/wAakGQBk5Pc0VIiIIEuFwW5RurE9x61LUZ/4+E/3G/mKkoAKKKKACio/Lb/AJ7P+S/4UeW3/PZ/yX/CgCSio/Lb/ns/5L/hR5bf89n/ACX/AAoAkoqPy2/57P8Akv8AhR5bf89n/Jf8KAJKgaytXYs1tCzE5JMYyTT/AC2/57P+S/4UeW3/AD2f8l/woAWKGOFdsMaxqTnCKAM1zcXgTTf+Er1DXr0yXM91dRXMcYlkSOMxxIi7kD7JCChZSy/KTxzzXR+W3/PZ/wAl/wAKPLb/AJ7P+S/4UbO4dLGXN4V0ebR20xrZ0tjcNdDyriSORJWkMhdZFYOp3Mx+UjqR04qOfwbolxplpYm3mhis93kvbXk0My7vv5lRw7bjy2WO48nJ5rY8tv8Ans/5L/hR5bf89n/Jf8KA63Mb/hCtAGoW14lgYntViWOKKeRIf3f+rLQqwjYr/CWUkYGDwMOtfB+iWeqNfwWsvmlpHWOS6lkhjaTO9khZjGhOWyVUH5m9TnX8tv8Ans/5L/hR5bf89n/Jf8KAMGDwF4dt7O6tVs55ILq2No6T3s8oSE9Y497nylPHCbRwvoMXX8M6RItwHtMi5u4r2X94/wA00WzY3XjHlJwODjkHJzo+W3/PZ/yX/Cjy2/57P+S/4U7sDjJfAF1J4ufXE1K0iMc73VrAlrOUSYxmMO6m4KHhiWKJGzHq3UHUGj+Ir5XtPEWqaJf6ZOjR3NtDpEsLSKQRgOblgv12n+tb/lt/z2f8l/wo8tv+ez/kv+FLpYN3c5648E2Y0K/03TZHi/tJRFd3F/JLfSyQ4wUDyyFh8pbbklVLE7Tk5taj4P0TVb1bq9tpS4jSJ0iupYo5kUkqksaMFlUZPDhhgkdDWv5bf89n/Jf8KPLb/ns/5L/hQBkXfhDRb2S9ea3mV76WOaZoruWIiSMALIhVh5b4ABZMEgAEkVYsfDul6cLP7HbbDZRyRwMZHYgSEFySSSzMQCWbJJyc8mr/AJbf89n/ACX/AAo8tv8Ans/5L/hR5AUbXw9pdlJYPbWuxtOge2tT5jHy4327l5POdi8nJ4+tRSaVeafolrp3hS5s9OW2ARPtttJdqIwMbcCVGz05LGtPy2/57P8Akv8AhR5bf89n/Jf8KAML/hHr/VrSS18YXtjqEQdJLdtOtZrGSF1P3hIJ3YHtlSpxkcg1safp9rpWnxWVhEIbeFcIgJPuSSeSSSSSckkknmpfLb/ns/5L/hR5bf8APZ/yX/CgAn/495P9w/yrK1DwnpGp30l3dQziSYBZ1hu5oY7gAYxLGjBZOPl+cHI4PHFarQllKtK5BGDwP8KPLb/ns/5L/hWlOpOm7wbT8tAMaay8VCZ/ses6LDb7j5Ub6PKzIvYEi5AJA7gD6CrkmhWE+ixaXNE32aMoyiOV0ZWRgwYOG3A7hnOc+pNXfLb/AJ7P+S/4UeW3/PZ/yX/Crdeo7Wdrdkl+VhWRl3XhTRb2wgsp7IfZ7e2e0jRJHTELqFaPKkEqQBwe4B6gGoprPxV57/ZNZ0aKDcfLSTSJXZV7AsLkZOO+B9BWz5bf89n/ACX/AAo8tv8Ans/5L/hQsRVWjd/Wz/O4WRRGgacdDutIktwbO8877RGHYBzKzNJznIyWY8HjPFWLTTbWwmupbWLy3vJRLOdxO9wioDyePlRRx6VN5bf89n/Jf8KPLb/ns/5L/hUOrUaacnr/AF+iCxnz+G9KudaXVprZjdqVJImcRuy52s0YOxmXPDMCRxg8CtSo/Lb/AJ7P+S/4UeW3/PZ/yX/ClKpOdlJ3tsOxJRUflt/z2f8AJf8ACjy2/wCez/kv+FQBJUcP+rP++3/oRo8tv+ez/kv+FCwlRgSv1J6D/CgCC20uztJr6W3h2Pfy+dcncT5j7FTPJ4+VFHGOlV9K8O6XojK2l2vkFbWGzH7xmxDFu8teSem9uepzyTV/y2/57P8Akv8AhR5bf89n/Jf8KAMzVfC2j63fQ3epWrSzQrsys0kayJuDbJFVgJEyM7XDDrxyarXFn4xa6ka113Q44C5MaSaLM7KueAWF0ATjvgfQVueW3/PZ/wAl/wAKPLb/AJ7P+S/4UAc/D4B0GK485obuTdOblrd9RuWtmlL7y32dpDH987sbeDz1FOvPAmg3+oXd3cxX2+9cPdRR6ncxwznaE+eFZBGwKqAQVwQMHNb3lt/z2f8AJf8ACjy2/wCez/kv+FAFeDSrK21Ka/t7dY7iaCO3dlJwY4yxRdvQY3t0Hf2FY48ParpCC18H3+maZp+5pPs13p810VdmLNtIuECrk8IBgc464roPLb/ns/5L/hR5bf8APZ/yX/CgDnT4Lg1GcX+v3U8mqtEIZbnSbu705JEVmKAxxznpvbkk9T06VYv/AAVoepyrLeW9wz+SsEpjvZ4/tMa8BJtrjzhyeJN33m9Tna8tv+ez/kv+FHlt/wA9n/Jf8KAKcuhabNqGnXr2iefpiutmykqIQ67WAUHHQAcjjtUaeG9HSz1G0/s+F7fU5nnvIpAXWZ3ADEhs9cDjpWh5bf8APZ/yX/Cjy2/57P8Akv8AhQGxl6X4V0jSHnktoJppZ4xFJNe3Ut3I0f8Azz3zMzBOSdoOMknHNQaf4J0HTLyO5tLWYvCjJbpNeTTR2ysMERRu5SIY4+QLgcDjitvy2/57P+S/4UeW3/PZ/wAl/wAKAMWLwR4egSNItOCiKK1hT96+Qls++AZ3fwsc+/fNb1R+W3/PZ/yX/Cjy2/57P+S/4U7tgA/4+H/3F/mar3ukabqVxaz6jp9rdzWb+ZbSTwK7QP8A3kJGVPA5HpVjyTuLea+SMHgf4e9Hlt/z2f8AJf8ACkBSj8PaLFepeRaRYJdRzSTpOtsgdZJBiRw2MhmAAJ6nvTY/DOgxaVPpkWiacmn3Ll57RbSMRSscZLJjBPA5I7Cr/lt/z2f8l/wo8tv+ez/kv+FAFSXQdHnFiJ9KsZBpxBst9sh+ykYx5eR8mMDpjoKSTRLA3t1f21tBaancw+S+owQR/aNuOPnZTnGAQGyOBxVzy2/57P8Akv8AhR5bf89n/Jf8KAMSDwuzpNBr2tXviGynj2PZapbWjQtyCCRHAhJGO5I9ulaEug6POLET6VYyDTiDZb7ZD9lIxjy8j5MYHTHQVb8tv+ez/kv+FHlt/wA9n/Jf8KAK8ekabFq0uqRafapqEyCOW7WBRK6DGFL4yRwOCe1Lpukabo1u8Gkafa2ELuZHjtYViVnPViFABJx1qfy2/wCez/kv+FHlt/z2f8l/woAkoqPy2/57P+S/4UeW3/PZ/wAl/wAKACb/AFY/31/9CFNvLO31Cxms72FJ7edDHLG4yGUjBBpzQlhgyv1B6D/Cjy2/57P+S/4UAUdI0Cw0QS/YftTvLgPLd3k11IQM4XfKzMFGSQoOMknHJqje+B9Bv7O2tZra4SO1u5L2E299PA8c0hYu4dHDZJd++BnjFbnlt/z2f8l/wo8tv+ez/kv+FG4GJL4J0K4szbXlvc3kbWs1oTd3087mKUqZFLu5Y5KLznIxxitSx0qy02W7ksofKa8lE05DE7nCKgOCePlRRgYHFT+W3/PZ/wAl/wAKPLb/AJ7P+S/4UXYElFR+W3/PZ/yX/Cjy2/57P+S/4UASUVH5bf8APZ/yX/Cjy2/57P8Akv8AhQAT/wDHvJ/uH+VSVG0JZSrSuQRg8D/Cjy2/57P+S/4UAZ8HhnQba3jgttE06GGO4+1pHHaRqqzf89QAMB/9rrUTeDvDLR2iN4d0kpYsWtVNjFi3JbcSg2/KS3PGOea1fLb/AJ7P+S/4UeW3/PZ/yX/CgCpFoWkW7XzQaVZRNqBJvSlugNznIPmYHz9T1z1NRP4Y0GTSIdKk0TTX06Bt8Vm1pGYY2yTlUxtByTyB3NaHlt/z2f8AJf8ACjy2/wCez/kv+FAGbqujX2oXKSWfiTU9JRU2mGzjtWVjk/MfNhc57cEDjpTrHw7pdhb3KLZW0kt6oF9cNbRK96cYLS7FUMTk54xyeK0PLb/ns/5L/hR5bf8APZ/yX/CgDPfwxoMmkQ6VJommvp0Db4rNrSMwxtknKpjaDknkDuasSaRps2qw6nNp9rJf26GOG7aBTLGpzlVfGQOTwD3qx5bf89n/ACX/AAo8tv8Ans/5L/hQBJRUflt/z2f8l/wo8tv+ez/kv+FAAf8Aj4T/AHG/mKkqIKVuFy7N8jdcccj0qWgAooooAr3101lYy3K2090Yl3eTbqDIw77QSMn26ntk8VQsfE2narfRW2ku18Hi86SaAAxwKfuhySMMecLy3ByAOa16igtbe18z7NBHD5shlk8tAu9z1Y46k+tAEWp3LWekXlzGwR4YHkVjC8oBCk52J8zdPuryeg5rzO1mm8QWWtapdanqRmWRhGba4vbCNQsCYxAzgrzk8jkknoa9Wrkdc8CWuseL7LVGjX7KVm/tCLz5FNwxRFjO1Tg4Cn0/GuLG4eriKXJSnyO6d1+RcJKLu1ct+BtauNd8OC5u51nkR/L3iwnteiKeVm+Zjz94cH8DVG68cXtt4h1K1XQw+maXeW9rdXv2vD5mWMqyR7PmCmQbssMDkbjwOvRFjjVEG1VAAA7CuRTwPJP4s1bU7/U7kWV5ewXS2EEi+VL5UUaqZAU3Ah0zhGAIC7s9K7V8Wv8AWq/4JHRkcPjjUrq1Mlvolt5lzqcum6dHJqBXz3ieUSPIREfLULCzDG8npgcEyp40v76K0ttI0WKbV5Tcie2ubwwww/Z3EcmJRGxbLsu35BuByduMVebwbZjRksLa8vLV4r6W/gvImQzQSySO7FdyFSP3jrhlPynByeaiPge0jtLNdP1LUNPvbUzH+0YDEZ5fObfNv3xsh3uAxwowQNu0cUf1+H+e/wCA3a+n9b/pb8TIu/ijaWPiuLRruGytWEttb3MVxqSLdxyzgFQkAB81V3oGYOMZbAO2tHSvGz6n4xudF+y2UYgeVCg1FTeJ5ZwHktioKxt1VlZshkJADcWo/B8Nvqkd3aavq1vFmJri1S5BS6eNQqvI7KZC2FUHDgMFG4HnLofCMa61Hf3Wr6pepbySy2tpcSoY7Z5AQxVggkPyswAZ2AB4HAw/+D/wP6+8X/A/4P8AX3HOJ8R5tQ8NeIL2O2tYG07T5LkLZanHLc27AN+7niePMEvHQrIuQwJOOb83jq9h1i5i/saM6bZ6lb6dPdte4kLzLFtKxCPBAMyg5ZeORnpVh/h/a3NpewaprOral9psJNPSS6ki328L43BWWMbidq/NJvPyjnk5uy+DtPmS8VprkC81G31GTDLxJD5W0D5funyVyOvJ5HGGrXV/61/yB+Xn+S/Uop4xv5dbto49GibSbrUZNOivftmJd8Yfcxi2Y27o3UEOSeDgA10ep3p07Sbu9FvNcm2heXyIF3SSbVJ2qO5OMAVxT+EfEA8W/brZreLTLW8l1C2sm1IlJJmR15UWwaPczlmJeUA5wvORuD/hKtSV7LVtL02wtJ0ZJLnT9bmaeLIOGQG2TnOP4h/So+z5j0UvL/g/5WKOjePG1LSmvpIdLkgjvIbZ59M1ZbuFRKQud2xWDKzKCrKOCCCeQK138RpILrTol0+xjW+RZYvtuqLbNco0pRBb7k2yybQHKFkxvQZOci3feC5m0TVreO+m1W/1eNLae81KRImjiGQCohiVcpuZgNoJJ5YDGLureDYNVUQHVdStdPaBLafT4Hj8ieNc/KQ6MyZBwTGUJGOcgEVpf+uxPQ5uf4gajoV14hOtrpqwxa3Hp+mtc34giQNAkh82QxfIu3LZ+clmK9ACdC08fXOs2GkyeHdLtL+41FLncG1ILBE0Dqj4lWNt6kk7WC8/KcAEkaV14JtZ7u+uYNRv7Se6u4r1HgMWbadIxEXj3IfvINrBty4zgDJq7aeHYbWfT55L29u7iximjWa5lDtL5pUszcDnKjAXCgcAAYAX2fPT8v8AMp76f1/Wn4+RhaT4tv8AxHJZ2c1jJokesWEl1Y3UF0k06bDGHDI0ZRT+8BXlwR1APFWPBbapc3mrXV1rt7qmmpcG1s/tkVurM0ZKyyZiiTgvlQDn7mc/Nxo2HhSx06bSJIJbgtpNpLaQb2U7kk2ZLccn92uMY6nikj0++8O+HLPTvDNrbX7WwEf/ABMLw2+V5yxZInyxP+yByTTut/63/wAhW0GeKLu9WbSNM068ksJNTvDC91FGjvEixSSHbvVl3HYF+ZSME8ZxTvB+p3WqaCzag4lubW7uLOSUKF80wzNGHwOASFBOMDJOABVaXS9Y8RW6x+IILfRZrWZLiyu9I1E3EscgDKTiW3VfusVwQwIY8Dg1saPpNvomlxWNoXZELO0khy8jsxZ3YjAyzMScADngAcULRA+lv63/AOB9xeooopAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUARn/j4T/cb+YqSoz/x8J/uN/MVJQAUUUUAR4m/vp/3wf8AGjE399P++D/jUlFAEeJv76f98H/GjE399P8Avg/41HfXsGm2Mt5dsywQrukZY2cqO5woJwO/oOaiGr2DX1tZx3Kyz3MRniWIFwY/75IyAp7E4BPAzQBZxN/fT/vg/wCNGJv76f8AfB/xqSvK7f4keJZdPuZ5NOijmRbdreEaZcMLgTOVBDBsAcfKf4zwOaaVyXJLc9QxN/fT/vg/40Ym/vp/3wf8axvB+t3ev+H1u9Rt1t7pZpIpY1VlwVYj7rcg9iD3FZSan4s1PWteTR7rRorfSrsW8Vtc2MrPP+4jl5mWYBMmTGfLbHXB6Utilqro67E399P++D/jRib++n/fB/xrmJfHsEWhWurrouq3FnLZLfXE0MSbLSIjJLl3XcRhsqgZgB05XMNh41v57/X4ZPD2oXA0/Uks7RLRIi04MKSZJMu1cZLbnKDDIPv5WnZ3t/W9g6XOtxN/fT/vg/40Ym/vp/3wf8aztP8AENtqHh6TV1hngji81ZYZlAkjeJmV0OCQSGUjgkHsSKg1LUtS0+xiuZpLGP5VzAwYvPIT/q0+YYOOAfmyewxS6gbGJv76f98H/GjE399P++D/AI1l399qNpN5oW3W28+OFIXUmWfdjJVg2BjJ42n7pORni9e3rWmwR2dzdu+TtgVeAO5LEAfTOT2HBo6XAmxN/fT/AL4P+NGJv76f98H/ABrJvvEaQ6cZ7C2mumNp9qBVRiNSPlLgkHnB4GTwaZfeIngtQbe1kldTCJZQoMUbOV+U/MGzhs8AgZGaANnE399P++D/AI0Ym/vp/wB8H/Gs0eIImieRLO6YeebeIAIDO4JBC5bttJycDFObXovIgaC0ubiWYOfIjCB02HDg7mAyCcYBPtmgDQxN/fT/AL4P+NGJv76f98H/ABqlPrCRXCQx2l1OxjWWTykGYkYkAlSQx6HgAkY6U7Vr+TT4rd4YWnMs6xGNRliCD0yQM8dScUAW8Tf30/74P+NGJv76f98H/GsPUfErQWMk1pC5lS2mkMEsYyrxsqkMd4HGegzkcg9M3otZEt0sAsbrIKpK4VCsLsoYK2GJ6EcgEc9etAF7E399P++D/jRib++n/fB/xpxdhMqeWxUqSZARgdOOucnPp2rHudXuoryaRBCbK2uY7aRSpMjF9vzBs4ABccYOcHkUdbAa2Jv76f8AfB/xoxN/fT/vg/41Ri120lNxlZE+yqTPuA/dkEjacH7xxkAZ4x6jNK31q+u7OICKG3u57yS3USAsI1UMckAjccLjgjk0AbeJv76f98H/ABoxN/fT/vg/41ix6vfXght7QW8d3++85pEZk/dOEIADA/MSDnJwPWo38Q3M9mbyyjhWKCyS8njkBZmDZOxSCNpAU8kHqOKAN7E399P++D/jRib++n/fB/xrHm1m5W5lmiEJsYLiK3kUqfMYvt+YNnAA3jjBzg8iiLWbn7VFLKIfsVxcy20YVTvQpu+YtnBB2NxgYyOTQBsYm/vp/wB8H/GjE399P++D/jWCniG6gtlub2OFo7iye8gSMFSgXB2MSTkkMPmAHQ8VoafeXbX09jqJheaOJJleBCilWLDGCTyCp5zznoKAL2Jv76f98H/GjE399P8Avg/41U0u7uLrT3uLgI7ebIESJdvyqxUDluTx14HNUYdduzZ38lzZrHPDdLbwwB85LhNu5hkZy/OOB79SAbOJv76f98H/ABoxN/fT/vg/41VtP7TS6Md+beeIpuWaCMx7Wz90qWbOeoI9D7VUk1S7t7i787yXgtriNW2oVYRuBz948gkHPcA8UAauJv76f98H/GjE399P++D/AI1JRQBHib++n/fB/wAaMTf30/74P+NSUUAR4m/vp/3wf8aMTf30/wC+D/jUlFAEeJv76f8AfB/xoxN/fT/vg/41JRQBHib++n/fB/xoxN/fT/vg/wCNSUUAR4m/vp/3wf8AGjE399P++D/jUlFAEeJv76f98H/GjE399P8Avg/41JRQBHib++n/AHwf8aMTf30/74P+NSUUAR4m/vp/3wf8aMTf30/74P8AjUlFAEeJv76f98H/ABoxN/fT/vg/41JRQBHib++n/fB/xoxN/fT/AL4P+NSUUAR4m/vp/wB8H/GjE399P++D/jUlFAEeJv76f98H/GjE399P++D/AI1JRQBHib++n/fB/wAaMTf30/74P+NSUUAR4m/vp/3wf8aMTf30/wC+D/jUlFAEeJv76f8AfB/xoxN/fT/vg/41JRQBHib++n/fB/xoxN/fT/vg/wCNSUUAR4m/vp/3wf8AGjE399P++D/jUlFAEeJv76f98H/GjE399P8Avg/41JRQBHib++n/AHwf8aMTf30/74P+NSUUAR4m/vp/3wf8aMTf30/74P8AjUlFAEeJv76f98H/ABoxN/fT/vg/41JRQBHib++n/fB/xoxN/fT/AL4P+NSUUAR4m/vp/wB8H/GjE399P++D/jUlFAEeJv76f98H/GjE399P++D/AI1JRQBHib++n/fB/wAaMTf30/74P+NSUUAR4m/vp/3wf8aMTf30/wC+D/jUlFAEQDi4Xeyn5Gxhcdx71LUZ/wCPhP8Acb+YqSgAooooAKKjzN/cT/vs/wCFGZv7if8AfZ/woAkqhpeh6Zovn/2VZx232iTzJdg+8f6Ac4A4GTgc1bzN/cT/AL7P+FGZv7if99n/AAoAkryWXwR4oXTja29mqTJbWkCXK67PgNA5YuEK4wcjavRDyOTXq2Zv7if99n/CjM39xP8Avs/4U07EuKe5z/gTSNR0Tw19l1ohrxriWV2Epk3bm3Z3Hknnkmqz+F/EEGq6zNpHiCys7XV7gTyK+mNJPCfKSI7JPOC5xGCCUIBPII4rqczf3E/77P8AhRmb+4n/AH2f8KT1KWisjg/Enwsh1qwi061u7OPTotPWwigv7A3f2baGAlgPmKI5SG5chidq9Mc2b/wBeXf9oBNXtmivbyK8e2urAywyssAhdJkEq+ZGQqsF4wwBO7pXZ5m/uJ/32f8ACjM39xP++z/hR38/+HA57w94QXQvBc3h/wC0QvHI07Ibe2EEcXmuz7VTccKpY4GegFX57PUdQs/LkuI7aOeHy7iB4RJt6hijBhjIPcN246itLM39xP8Avs/4UZm/uJ/32f8ACh67hsZS6PfR6t9sS+t5EUBIkntWdoUwAQpEgAJxycZP0AFTaxpDao0OJYdkYYNDcwedE+cc7dy/MMcE5xk8VfzN/cT/AL7P+FGZv7if99n/AAo3DYxP+Ebni09baz1BYmNmtnNI1vu3oudpA3DaRuPr16U+fw/O6vFbXywwTNE8ymDczMm0cHcMAhBkYNbGZv7if99n/CjM39xP++z/AIUdbgZM/hxJ9LW0eSGRo7p7lDPAJI8szHDJnkYcjqPWmTeHC+mQWaPYmOPcWjl09WiLE/eVARtIyQOTwecnmtnM39xP++z/AIUZm/uJ/wB9n/CgOtzHvvDrXiW8Ruo3ihjWNXnthJMhHV0kyCrHA5weQDWhqNlLeRQ/Z7gQSwyiVXaPeCQCMEZHHPrVjM39xP8Avs/4UZm/uJ/32f8ACgDFk8M+dDIst2TJLb3EUjiPq0rKSwGeANuAOeO9PfQZp9Rgurm5tnaJkYSJaBZhtH3Vk3cITnggnBIzWvmb+4n/AH2f8KMzf3E/77P+FADiJPOUhlEe07lK8k8YOc8DrxisufRXnvpH+1AWk00c8sBjyzOmMYbPAO1cjB6dRmtLM39xP++z/hRmb+4n/fZ/woAyk8Oxs8pu7iSYXDCSYKzRlpA2VZSrZXAwMf7K+nLIfDn2SAizvJFnW7a5jkmLSgZyNpDNk8MQSCCTzWxmb+4n/fZ/wozN/cT/AL7P+FAGUNCmgigayvRFdR+b5krw71k8w7n+XcMfMARzxjHNNl8OfuFtrO6MNu9qtpOjR7meNc4IORtbDMM4PXpxWs8kqIzGNMKMnDn/AApczf3E/wC+z/hQBmzaG0t45W5C2cssc8lv5eSXTGMNngfKuRg9OozRFojJfI8lyJLSKd7iGDy8MruDnLZ5HzNgYHXqcVpZm/uJ/wB9n/CjM39xP++z/hQBkQ+HP3RhvLszwpbPawBY9jRxtjOTk7mwqjOB06c1b0/Tpra4lub25W5uZESPekXlqEXOOMnnLEk5/AVczN/cT/vs/wCFGZv7if8AfZ/woAp6LFNBp5huYGhdZpSNxU7gXLAjBPGD3wfamPoqSx36STN/pc6zqyABomVUAIznJBQGr+Zv7if99n/CjM39xP8Avs/4UAZlnojxax/ad5LbSXIjMe63tfJ35xkuSzFj8oxyMc1DNZXd1cX8ZtmjiuriJd7sv+rUDc2ASecYHfnpWzmb+4n/AH2f8KMzf3E/77P+FAElFR5m/uJ/32f8KMzf3E/77P8AhQBJRUeZv7if99n/AApFklcZEadSPvnscelAEtFR5m/uJ/32f8KMzf3E/wC+z/hQBJRUeZv7if8AfZ/wozN/cT/vs/4UASUVHmb+4n/fZ/wozN/cT/vs/wCFAElFR5m/uJ/32f8ACjM39xP++z/hQBJRUeZv7if99n/CjM39xP8Avs/4UASUVHmb+4n/AH2f8KMzf3E/77P+FAElFR5m/uJ/32f8KMzf3E/77P8AhQBJRUeZv7if99n/AAozN/cT/vs/4UASUVEJJS5Xy0yAD9898+3tS5m/uJ/32f8ACgCSio8zf3E/77P+FGZv7if99n/CgCSio8zf3E/77P8AhRmb+4n/AH2f8KAJKKjzN/cT/vs/4UZm/uJ/32f8KAJKKjzN/cT/AL7P+FGZv7if99n/AAoAkoqPM39xP++z/hRmb+4n/fZ/woAkoqJpJUGTGnUD757nHpS5m/uJ/wB9n/CgCSio8zf3E/77P+FGZv7if99n/CgCSio8zf3E/wC+z/hRmb+4n/fZ/wAKAJKKjzN/cT/vs/4UZm/uJ/32f8KAJKKjzN/cT/vs/wCFGZv7if8AfZ/woAkoqJ5JURmMaYUZOHP+FLmb+4n/AH2f8KAJKKjzN/cT/vs/4UZm/uJ/32f8KAJKKjzN/cT/AL7P+FGZv7if99n/AAoAkoqPM39xP++z/hRmb+4n/fZ/woAkoqPM39xP++z/AIUZm/uJ/wB9n/CgCSio8zf3E/77P+FGZv7if99n/CgAP/Hwn+438xUlRAubhd6qPkbGGz3HtUtABRRRQAUUUUAFFFFABRRRQAVj/wDCX+G/+hh0r/wNj/8Aiq2K8+g+E1ta2F1Y2uvahHaXfliWMxwsWEbbk52Z4J7Yz3pq3Ul36Hd2l5bX9qlzY3EVzA+dksLh1bBwcEcHkEVl3Xi3RrLWRpdxcyi5MiRMy2srRRu+NiPKFMaM2VwrMCdy8cjL/DHh6Lwxoi6bb3ElwiyPIJJAAxLHJzjjqTXMeJ/CfiTWvEAmjuYJbKO9tbm2L6nPAIEieN2ja3RCkuWRjvdiRuGANopfaS6FdNTduPGukqkf2S5jlkaWKNkkSVNm+48jDYQlW3hgFYDJU8gAsOhrzx/Aur+deXHm2G/U9QtdSvQpYeXJBcI21CEy4MKhecfMmcfOcdFF400q6nS3S111WlYIC+gXyKCeOWMICj3JAFC+Hz/4b9bje/kUm+I+inXI7GBpXgFvc3E128EsaKkGNzRkpiZeT8yEgY75FSN8SfC6rIWvbkeWokcHTrnKxHOJseX/AKnj/W/c/wBqsL/hCPEcllaaXI+lrY6ZpN1ptrMJpDLP5kapG7rswmAvzAFuTkelbOs+FL7UbXWo4ZbdTf6ANMi3swxLiXk8fd/eDkZPXij+vz/4A7K/9eX+b+41LnxdotnrC6ZPcyC4LpEzJbSvDG742I8wUxozZXCswJ3Lx8wzsswVSzHAAyTXnuveEPEupanCwuYJbS2ubS4tydSuIVhWFo2eM2yIUm3MjEO7ZG4YA2iuhTxlpN5Itr9k1zMx8v8AeeH75F545ZoQAPckAUP4dN/6sSu7IfD/AIvm1jULWG901bKLUrRr7TZFuDI00KlQfMXYvlviRDtBccnniuorjfDPhbVtP1DTH1h7MwaHYPp9k1s7M1wjFP3kilQIztiUbQXGSTnpXZU3bp/Wun4WDqFFFFIAooooAKKKKACiiigCOf8A495P9w/yrm77xVqCarqdtpGjx38WkBDeKbspcNuUP+5hEbeZ8p4yybmDKOma6Sf/AI95P9w/yrkvEvhrUtau50fT9F1GFx/od7esY7jTCygEx7Y2LYZQ4IdDnjIwGrtwapOo1VtbzfmvNX08183o09jsFbegYAgEZwRg/lWOniJJfE9xo0UILRQkrMz4VpQFZounGFkjbPPU8fLUB8V6fY/6JPFrU0sH7t5F0O8cORwSGWIg5x1BINZi+DJoRb6zZyvJrq3n2x1nv51tmLkiRNnKr+7YqG8vPAz3qqVCEb+3TV/h069+mnf1Ju7abk1144eDR7y7j0wvNp1jNc38Bn2/Z3jyBFu2/MWKtg4Hyjd3APWI2+NWxjcAcVw9/wCC9Wk0fUYbS7tpLrWtPmg1IzOyo07KdkiYBO1clMHnZt5JQA7cni3TrSRraW21hnhOxjFol5IpI44ZYiGHuCQa0r0Kc4r6srvW9rvTT9b28rX1C7W/9bW/Ut6LrP8AbGlzXnkeT5VzcW+zfuz5Urx5zgddmcds9650eM9cuLPw/dWOg6e8OvJH5Hnao6NG7QNMQwEDDACMMgnPHA7WdBsfEelRy2RsNLlsZr24nFz/AGhKsoSaZ5B+6MGNwD4xv7daWw8LXtro/g60kltzJoRQ3JVmw+LaSI7OOfmcHnHGfpVqGGpzm5JNXfLq9rSts+9twbbvbz/4A638QeJL7UNQtdP0PS2/s+ZIJmn1aRMyGJJDtAt2yo8zGTgnHQV1C5KjeAGxyAcgGuDvPBlw/ibV9Ql8K+GdbW9uEmhn1KcrNEoijTZj7PJxlCeG/i6V3abvLXzFVWwNyqcgH2OBn8qwxcaKUHSS1SvbvZX+0+t+iGr3aY6iiiuAoKjh/wBWf99v/QjUlRw/6s/77f8AoRoA5SfxT4gm1HW4tH0LTJ7XSJvJklu9WeB5D5KSkhRbuAMSAct27VbHjzQk0/S7u6mnt11O2S6jU20jmKN9uGlKBliXLAbnIXrzwaxNV+Fel6/N4judXs9Pa+1C8S4sL/7Osk1tshiVcll5AeMkpypBwepFQ6/4G1rX7qC+vIrGS5utNSw1CKPVry2gj2sxLKsO0zqRI+Y329AA3JNEel/L8v8AP7vybtfT+tV+n3nU6l4y0PSNUGn391Kk5aNWKWsskaNI22NXkVSiMx6BiCcj1rcrzLxDFqkPiS70TR7KS6g1S/sruWZ7W5HkGMxBx5nl+Sy7IQcmUMDkbWOBXptC2uLqFFFFABRRRQAUUUUAFFFFABRRRQAUUUUARj/j4f8A3F/mawde8US6ReTRW1lFcxWNqL3UXkuDEYYCWAKDYwdvkc7SVHy9ea3h/wAfD/7i/wAzWDr3heXV7yaW2vYraK+tRY6ikluZTNACxAQ71CN87jcQw+bpxR1Q9Lf1/Wxfh8S6FcXy2VvrWny3bSvCtul0hkMiDLptzncoIJHUDrWHb+PRqMd2NJ08SzrqY06xW4mMSXRMCzeYWCMVTYWIIVsgA9+JW8IXc+u3V5eajbyWt6s0Fzax2jxloGRVRVcS5Vxt+aQDLAgYARNuVpvw1utKv9QvbXXN88t6l5Ym5W6uBbMsZiw4kuW8zMZIJBQ89doVQLz/AK1/y/rYOn9f1/X3al346gs9J064ezaS7vL9bF7aKTcIXFwIJXL4+4jHrgZJUcFuLFr4pkuNcSBrOJNNnu5bG2uxcEySTxBy6mPYAF/dyAMHJyvQZrD174Xrq+kwRWmqyWeorOs1xdK9yscxE7Tn9zFcRgZkYkElmUHg5AYa0HhefTLwXKzi8sbKaa/tbCKDE5uZFcP+9eXaQfMkwCF5bljimrdfP9P+CJ7af1/WnyNXXdWl0u3tks7eO5vbycW9rDLMYkd9rOdzhWKgKjHIU9OlYUnjyT7O8tvp0MgsIHuNWDXZX7KiSPG/l/IfNO6GXAOzIXqM4E9w+p+JXgQaFqGg3VjJ9qtb3URbTwiQAoVKQ3BZsq7jqo9+xgk8ByfZ3it9RhjF/A9vqxa0LfakeR5H8v5x5R3TS4J34DdDjJS8/wCv6+8bt/Xrr+GxLN45S0mnury1ij0VJLiCK8W4LSvLAjtIDFsAC4ikAIcklegzWloet3eoXNxZ6rYw2N7DFHceVBcmdTFJuCEsUQhso4IxgY4JrNm8DJdzT2t5dRSaK8lxPFZrblZUlnR1kJl3kFcSyEAICC3U4rS0PRbvT7m4vNVvob69mijt/NgtjAoij3FAVLuS2Xck5wc8AUK1hPy/r+l+PkbVFFFAEc3+rH++v/oQqHVNRg0jSLvUrvd5FpC80mwZYqoJOB3PFTTf6sf76/8AoQqprmlR654fv9KmbYl7byQM2M7dykZx369KT20HG19TK8N+LRrVnqF1eDTIYLI/PcWOqJdxKAMsrsFUo64+ZSMcjDHnFGw+IkF7a6fdS2DWdveanc2TPcyhDCkMcsnmsCOMiLlTjGeTxiox4O1LWvts2vXKaPJcQWtusWjTiZNsDs4YmaED5i+ChQjauMnPGdD8MbmZLS21+9j1uzj12fUZor1UIeN45VUbUiUFizqWB+Xg444p9X6fqv0voLp/XZ/rY7bR9Tn1aOW5Nk1tZsR9leRiJJl7u0ZA2A9gSSQckL0rRrD8MaTfaDbT6ZNMk+m27406Qys0yQn/AJZPkfwdFbJJXGcEZO5TdugBRRRSAjubmCztZbq8mjgt4UMkssrhUjUDJZieAABkk1S03xFous4/sjWLC/yMj7LdJLn/AL5JrRrI0Pwro3huS5bRbGO0Fw+9kjGFT/ZUfwrnnA4/AAAA05/+PeT/AHD/ACqLUb+DStLutQuyVgtYXmlIHIVQSf0FSz/8e8n+4f5VFqNhBqul3Wn3YLQXcLwygHkqwIP6Gk720HG11cxbHxbHHO1r4o+waLdnyTDGb4Osom3iMBmVP3hMbjYAenBNN1bxxpljp+nXWmyR6umo3kVtC1nMrphplieQuMjahcA/7RC8E1XbwhqVzby/2hq9rLc3DW8M80Vi0ebaFmZUX96SkhZmPmg8ZyqqQCM3W/hrda3oNhby62INTtRDG95AlzDFLHDJvRfIiuUUNnHzZJHJXacba0v81939f8AS21/r+v8ALztuWviqS41tIGs4k02e7lsbe7FwTI88Qcupj2ABf3cgDBycr0Gap2/j0ajHdjSdPEs66mNOsVuJjEl0TAs3mFgjFU2FiCFbIAPfh6eBw85t728SbRxLNcR2ixOkyzTI6yEzeYSVPmyEAAMC33jiszTfhrdaVf6he2uub55b1LyxNyt1cC2ZYzFhxJct5mYyQSCh567QqhLz7fqh6a/16f8ABOw0XUxq+lpdGMRSCSSGaNX3hJI3KOobAyAynBwMjsOlczB47u7j4gX3hePT9PaW1L426i5mKCJHWRo/JwiEyomdxOc4DAGtCKW98L2sVhaeH9S1suXuJ7qyNrEhlkkZ3+WWdWHzMTjkAEDJOaNF0G8hvtX1i5e2S71RvOt0lsh5tjmKNDG7LKwcfuoy20qCVPPTCfVrs/v6ArHMWHxauL/wXdeIU0zSRFbzWsTkaw/kxGYqGEkpgAVo/MQsAGABPOQRU198UbqztPD840vTT/bcLyQCTU5E81hIiIkQ+zkyFxKjLkJxndtAJrUj8D3Vv4DsNAtNRsYrq2ltZJr3+zji4+zshTcglB3ERRqSWPA4A4xo3PhUTeJNJvI2sY9N021e3XTzY5HLRurK28Km1oYyBsOMH2xfu83lf8Lfqw0OhByAemfWiiipERn/AI+E/wBxv5ipKjP/AB8J/uN/MVJQAUUUUAR+Y3/PF/zX/GjzG/54v+a/41JRQBH5jf8APF/zX/GjzG/54v8Amv8AjUlFAEfmN/zxf81/xo8xv+eL/mv+NSUUAR+Y3/PF/wA1/wAaPMb/AJ4v+a/41JRQBH5jf88X/Nf8aPMb/ni/5r/jUlcvZ+P9Hv8AxXd6DZnzZrO4+zTTC5twiyeWzldpk8w4CkHCHkN/dYg62Dpc6TzG/wCeL/mv+NHmN/zxf81/xqDTtX03WIXm0jULW+ijfY72syyqrYB2kqTg4IOPcVl674vs9BvGgntLy4WCAXN5NbqhSyhLFRJJuYEglX4QMcITj1OtgNvzG/54v+a/40eY3/PF/wA1/wAakByMjkUUAR+Y3/PF/wA1/wAaPMb/AJ4v+a/41JRQBH5jf88X/Nf8aPMb/ni/5r/jUlFAEfmN/wA8X/Nf8aPMb/ni/wCa/wCNSUUAR+Y3/PF/zX/GjzG/54v+a/41JRQBH5jf88X/ADX/ABo8xv8Ani/5r/jUlFAEfmN/zxf81/xo8xv+eL/mv+NSUUAQTSMbeT904+U8kj0+tP8AMb/ni/5r/jRP/wAe8n+4f5VWk1rS4dXi0qbUrOPUZl3x2bTqJnXk5CZyRwe3Y1UYyl8KuBZ8xv8Ani/5r/jR5jf88X/Nf8akrNi8R6JNLdRQ6zp8klmcXKJdITAc4w4z8vPHPenGEpfCrhsXvMb/AJ4v+a/40eY3/PF/zX/Gqy6taSaqunwyxyylZC2yaM+WU2ZUru3Z/eKeAQMjJGRmzNcQ2+z7RNHF5jiNN7BdzHooz1J9KThJWutwDzG/54v+a/40eY3/ADxf81/xot7iC6hEtrNHNGSQHjYMpIJBGR6EEfUVVn1vSrbVIdMudTs4b+cborSS4VZZBzyqE5PQ9B2NNQk20lqgv1LXmN/zxf8ANf8AGjzG/wCeL/mv+NUrjXtOhiidLu3nMzIqLHcRgsGkWPcNzAEBmAOOc8AEkA5V3490my0i51K5EsdvbLdM+94lZjby+UwVS4JLMQFxxyASpIB1hhq07csd3b5gdF5jf88X/Nf8aPMb/ni/5r/jVKLxDo01zZ20erWLXF9EJrWEXKF54yCQyLnLDAJyMjg1o1jKEofErCTT2I/Mb/ni/wCa/wCNMikYIf3Tn5m7j1PvU9Rw/wCrP++3/oRqRh5jf88X/Nf8aPMb/ni/5r/jXN3PjSRNR1O1sPDGs6kumSiK4ntWtQm7y1kwBJOrH5XX+GtJfFWhG10y4k1ezgTV1VrAXEyxNc7gCAisQWPzLwBnkULX+u4bGl5jf88X/Nf8aPMb/ni/5r/jVK88Q6Np+pRaff6vYWt7MoaK2muUSSQE4BCk5Izxx3rRoAj8xv8Ani/5r/jR5jf88X/Nf8akooAj8xv+eL/mv+NHmN/zxf8ANf8AGpKKAI/Mb/ni/wCa/wCNHmN/zxf81/xqSigCPzG/54v+a/40eY3/ADxf81/xqSigCPzG/wCeL/mv+NHmN/zxf81/xqSigCPzG/54v+a/40eY3/PF/wA1/wAakooAgEjfaH/dP91eMj1PvT/Mb/ni/wCa/wCNA/4+H/3F/maydY8TW+jXawSWl1c7IvPupINm20hzjzZNzAleG+6GPynijrYDW8xv+eL/AJr/AI0eY3/PF/zX/GpOtc7H4ytLyLUDo1hf6tJY332F47REBkkCK7FWd1UKA2NzMoyCBkkZAN7zG/54v+a/40eY3/PF/wA1/wAa5dviBbPYx3Fno2q3j+VJNc28Kw+ZaJG7IxfdIA3zI4GwvnaSMjmtG28UW11rX2BLW5ELSvBFfHy/JmmQEvGuG37gFbqoHynBNAGv5jf88X/Nf8aPMb/ni/5r/jVTWNWTR7RJTbzXc00gigtrcoJJnOTtXeyr0BPLAYBrJl8b2UcUMiWN7KvltLebBHmwRXKM0oLjoyuDs3n5Gxkc0bgdD5jf88X/ADX/ABo8xv8Ani/5r/jWIfGFhHqE8M8FxDZxGRBqL7PIeSNS0kYwxfKhXPKgfKcE1a0XXl1nzkexu9PniVXMF35e9o3zskGx2GDtbvkbTkChahsaPmN/zxf81/xo8xv+eL/mv+NSUUAQSyMUH7px8y9x6j3p/mN/zxf81/xom/1Y/wB9f/QhTb28g0+wnvb2QRW9vG0ssh6IijJP4AUbBvoO8xv+eL/mv+NHmN/zxf8ANf8AGs7R9bfVRP8AaNJ1DS2h2sBfIgEiMCQysjMvY5BIYdwMjNDTfHekatHYSWK3EkWoX81hBJsAUvGjuX652ERnB6nI4o62Dpc6DzG/54v+a/40eY3/ADxf81/xqnpWsQ6x58llFMbWNtsV2wUR3HqY+clQRjcQAf4SRzWhQBH5jf8APF/zX/GjzG/54v8Amv8AjUlFAEfmN/zxf81/xo8xv+eL/mv+NSUUAQTSMbeT904+U8kj0+tP8xv+eL/mv+NE/wDx7yf7h/lSXVzDZWc11dSCOCBGkkc9FUDJP5Chu2obi+Y3/PF/zX/GjzG/54v+a/41naLry6z5yPY3enzxKrmC78ve0b52SDY7DB2t3yNpyBS674hsPD0No+oM+by7is4I41yzySOFHHoM5J7AHvgF21sG5oeY3/PF/wA1/wAaPMb/AJ4v+a/41g3HjGCx1b7LqOl6jZWrNKseoTpGIZDGjO+FDmQDajncyBTjgnK5ij8bq0LmbQNWt7hvK+y2sogEl35m7b5ZEpUcIxIdlIA5FIDo/Mb/AJ4v+a/40eY3/PF/zX/GoNM1GLVdPju4EeMMWVo5AA8bqSrI2CRkMCDgkccE1hp44hfxRc6GNH1DzreR4vOL2+yRliWXCjzd+Crp8xUAF1BIJoegHR+Y3/PF/wA1/wAaPMb/AJ4v+a/41xtp8TrS80F9Uh0HViqvaqsG+1Mj/aCBGeJyq/eTIYqwDqcYOadc/Euzt7XT5xoupypfwyTKY5LXCKkixnJM4DEmRNuwtu3jbnpTs72DU7DzG/54v+a/40eY3/PF/wA1/wAakBDAEcg9KKQEQYtcLlGX5G6455HpUtRn/j4T/cb+YqSgAooooAKKj85fR/8Av23+FHnL6P8A9+2/woAkoqPzl9H/AO/bf4Uecvo//ftv8KAJKKj85fR/+/bf4Uecvo//AH7b/CgCSvJoPg5e21hdWa6hpUy3HlgTzaeTLHsbOVO/5S3RuuRxXqvnL6P/AN+2/wAKPOX0f/v23+FNNolxUtzG8G6BN4Y8NxaXcXCXBikdldFKrhmLYAPTkmucm8M6u3i6S9W0zbnX3vA/mp/qTpvkhsZz/rPlx174xzXeecvo/wD37b/Cjzl9H/79t/hSet/NW/L/ACLWisv66HIeHta0PwT4O0LRPFGs6Vo2o2+nQrLa3V9DGwIUAnBbkbgeRweaz9dhufEP9rz+FEg1rT/EelDTlv7S8ieK1kUyqXfLDKYl/g3NlCCORXf+cvo//ftv8KPOX0f/AL9t/hTb5ndgnbYWCIQW8cSnIjUKCe+Bin1H5y+j/wDftv8ACjzl9H/79t/hSepKSSsiSio/OX0f/v23+FHnL6P/AN+2/wAKBklFR+cvo/8A37b/AAo85fR/+/bf4UASUVH5y+j/APftv8KPOX0f/v23+FAElFR+cvo//ftv8KPOX0f/AL9t/hQBJRUfnL6P/wB+2/wo85fR/wDv23+FAElFR+cvo/8A37b/AAo85fR/+/bf4UAE/wDx7yf7h/lXG6hpmrHxi01jYXMdtLeQXE8kkltLZShFUGRlceekoVdq7PlyqEnlq7CWQNC6qrklSB8jen0p3nL6P/37b/CuihXdBtpJ3VtRSV1YxovHHhSedILfxPoss0jBEjTUIizMTgAANkkmuOttG8TPfJLeaJJJHHpVzYmyY2kdmjyGLAhEbeZ5PyHPmHdjGBnivSvOX0f/AL9t/hR5y+j/APftv8K3pYuNC/sob99e+1rW3Cz7nB6Rpc/hS+0241ySG20/SrS9t5tUurlFWdpZoHSRizZ3Phs5/iB7Fc6Otazo/jDSJtE8Oa1p1/d3RUE2d9G8lqoYEzgK27KYBXHO7b9R1fnL6P8A9+2/wo85fR/+/bf4U5Yznmqs4++ttdN76q3d90JR5djmdL8UaBoGk2mk65q+j6RfWUKwS2cl/EhTaMAgFshWADDPOCM81ia7aa1repedots0+mzXtneQz6e1p9nu443iYtM7nzWcbCFKYXAQZPOPQfOX0f8A79t/hR5y+j/9+2/wop4yNKp7WEPeffVb30Wj382Ll05eh55J4X1g3N9OmmAf2nqNpe7RMmbVYrtXaM5bHKlpfl43tJ3IzDd+DtbuNPvIEtAGmsdchXMqY3XFyrwjr/EoJ9u+K9J85fR/+/bf4Uecvo//AH7b/CtVmlZNNJaO/Xty9+xVtb/M8+ufDus3nik3LwarHa31xZXZSOezWK2MSplJSyvJuBQnERKtvxkZZq9FqPzl9H/79t/hR5y+j/8Aftv8K5MRiZV1FSSVlbT5L9EKMVHYkqOH/Vn/AH2/9CNHnL6P/wB+2/wpsUgVCCr/AHmP3G9T7VylHn+p/D691abxXdR3eoade3l6s1g0OpzRwTosEK7ZIo5ApVmR0YkBsdD0ql4h8L63qslvNbaXqVjb32jR6dLp2n3Fii2ZV2JV2lV8JhxhoQWGz7uduPT/ADl9H/79t/hR5y+j/wDftv8AChaW8v8AK39f8ONu/wDXnf8AQ8r8T38Fp4mv/D2y21G/1TUtPuoiLuAzRBGhBVod3m5URs4Kptw5JK4Jr1io/OX0f/v23+FHnL6P/wB+2/wo6WESUVH5y+j/APftv8KPOX0f/v23+FAElFR+cvo//ftv8KPOX0f/AL9t/hQBJRUfnL6P/wB+2/wo85fR/wDv23+FAElFR+cvo/8A37b/AAo85fR/+/bf4UASUVH5y+j/APftv8KPOX0f/v23+FAElFR+cvo//ftv8KPOX0f/AL9t/hQAD/j4f/cX+ZrmfEvhu/1K9vTp4tWg1fTxpt8Z5mRoYwXw8YCNvbEr/KSo6c10gkHnM218FQB8jep9venecvo//ftv8KOo7tHDR+BbgeLLnUF07SbKC5e5AntJSLi1MkaILmMmLHnPtIcE4AC4JO/fX0Pwj4p0L+3onOm6vZX0yCGyv7hFjlhEQiKv5VoojO1E4CupA24By59B85fR/wDv23+FHnL6P/37b/Cj/KwHG6V4b8Q6HNBcWTadPNcW/wBmulmnkVLNBNJJGIsITIsYmZAp8vIVeV6CaPQLzT9SSS5WFtI069udVhlhaSW5kklWXdH5Kp0BmcgqzE4UbRXWecvo/wD37b/Cjzl9H/79t/hTuxf1+Fvy0OUvdTj8TzWbaDbXw1DTJ/tkKanpt3Ywy/I0bKZZIcD5ZTjAY8dOpFCTwRqcdreRWwsmOuW0ttqm+4dRbiSaaUtF8h8zH2iQANszhTkdB3XnL6P/AN+2/wAKPOX0f/v23+FLYd3/AF96/E4q78C3WoRzaPdG3TRhPd3UNwkzGcvcJKrIY9oUAee53byTgcCtvQNM1KLUrrVNcjtIrua3htAlpO0qGOIuwclkTBJlb5cYGBya2vOX0f8A79t/hR5y+j/9+2/woE9f6+f56klFR+cvo/8A37b/AAo85fR/+/bf4UAE3+rH++v/AKEKoeJNLbW/C+p6XG4R7y1kgViSACykA5HI5ParssgZAAr/AHlP3G9R7U7zl9H/AO/bf4Umrqw07O557ZeENRvLTVYtKsI/B9pexW8b2U8EU4mdGYzSMsEoBEisqFt4chTkDiqEfw/1zUbaz0/xH5ctn/wkF1dT/wBn5tCLd4plzkSs21y6japDBWIPc16j5y+j/wDftv8ACjzl9H/79t/hT0v/AF5f5C6f12a/UxvCsGq6dZy6Tq6vMlgwjtNQZkP2qHHy7gDkOo+VsgAkZHUgbtR+cvo//ftv8KPOX0f/AL9t/hTbb1YbbElFR+cvo/8A37b/AAo85fR/+/bf4UgC5toLy1ltbyGOe3mQxyxSoGSRSMFWB4IIOCDXNeEfh7ofguS4OjQsqSOTErnd5Cf3QTye/J5xgepPS+cvo/8A37b/AAo85fR/+/bf4UAE/wDx7yf7h/lVbWdNj1nQr/TJmKR3ttJbsw6qHUqT+tTyyBoXVVckqQPkb0+lO85fR/8Av23+FD1Gm07o4i+8IarrQa51ex0j7c72kSsLhpRbRwO7i4jLRD99mRsKV2juWGVOVqnw716bwvpMOiSWekX1n5KSWVncIlmojnExkRntXfezKpIwBkDdv2/N6Z5y+j/9+2/wo85fR/8Av23+FO+t/mJaaf1/X9dzjNV8Kav4h1F49TTTbW3NtNbSajays11dwvG6CF08tQFUyb872BZAQq7vltzaZ4lvrOyub2HS11HS7lJrWCK7kMU5EbxsXkMWU3LIcKEbbt6nPHUecvo//ftv8KPOX0f/AL9t/hSD+vvOZs9StfCFjHY6nDqEl1PJLeS/2fpd3dxK8sryMoeOIjgsQM4OADgZqtoPh1x4m1zxXJpdkL3UADp85kljmMJiiXy5laJTH80Ktghiu5hjru6/zl9H/wC/bf4Uecvo/wD37b/Cje/3Dued2/w6nsfhbb+HrTSNG+2TXFrNqULXD/ZrkxNGXbPlHJdYVBGwDLEnJyTqX3gW3ufEXhpV0qwk0PQrVo4FluH863kDRNE0Y2nO3yQMlwSGIORkN2HnL6P/AN+2/wAKPOX0f/v23+FVzO9/n+Fvw6dhXZJRUfnL6P8A9+2/wo85fR/+/bf4VIAf+PhP9xv5ipKiDb7hSobAU5JUjuPWpaACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKACiiigAooooAKKKKAP/9k="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Address%20Editor.JPG](attachment:Address%20Editor.JPG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Convolution of coefficient h[] of n-order FIR filter with input signal x[] can be expressed by difference equation\n",
    "N-阶FIR滤波器的系数h[]与输入信号x[]的卷积可由差分方程表示：\n",
    "\n",
    "$$\n",
    "y[i]=\\sum_{j=0}^{N-1}h[j]\\cdot x[i-j]\\quad(2.1)\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ContiguousArray([ 0,  2,  2,  0,  0,  4, 10, 14, 14, 12, 12], dtype=uint32)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dma = overlay.const_multiply.multiply_dma\n",
    "# multiply = overlay.const_multiply.multiply\n",
    "\n",
    "dma = firol.axi_dma_0\n",
    "f = firol.fir_0\n",
    "\n",
    "\n",
    "from pynq import Xlnk\n",
    "\n",
    "xlnk = Xlnk()\n",
    "in_buffer = xlnk.cma_array(shape=(11,), dtype=np.uint32)\n",
    "out_buffer = xlnk.cma_array(shape=(11,), dtype=np.uint32)\n",
    "\n",
    "\n",
    "for i in range(11):\n",
    "    in_buffer[i] = 1\n",
    "\n",
    "filt = [1,0,-1,0,2,3,2,0,-1,0,1]\n",
    "actualfilt = [53,0,-91,0,313,500,313,0,-91,0,53]\n",
    "f.x = 2\n",
    "dma.sendchannel.transfer(in_buffer)\n",
    "dma.recvchannel.transfer(out_buffer)\n",
    "dma.sendchannel.wait()\n",
    "dma.recvchannel.wait()\n",
    "out_buffer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# drawing\n",
    "画图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xabf29e70>]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xac243f50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD8CAYAAABn919SAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzt3Xl8VfWd//HXhyyEJBBAQlgiBNkRRSCCYDtqRcHRumPFDbQtop22an/D2JnHb9pZfo9abIudulJBrForRYnWVhAX6iibgQRlSdiR3BASCCGQhKzf3x9k5sE4YELucu499/18PHjk5uYm5301eefk3O/5HHPOISIisa+T1wFERCQ0VOgiIj6hQhcR8QkVuoiIT6jQRUR8QoUuIuITKnQREZ9QoYuI+IQKXUTEJxIjubFevXq5nJycSG5SRCTmbdiw4ZBzLrOtx0W00HNycsjPz4/kJkVEYp6Z7WvP43TIRUTEJ1ToIiI+oUIXEfEJFbqIiE+o0EVEfKLNQjezRWZWbmabT/OxH5mZM7Ne4YknIiLt1Z499MXAtC/faWbnAlcDX4Q4k4iIdECb69Cdcx+ZWc5pPjQfmAu8GeJMIhJmpVV1LMnfT0tL5C9BmZjQiem52fTN6BLxbftdh04sMrMbgIBzbpOZtfXY2cBsgAEDBnRkcyISQs45vv9qARv2HaGNH98wbR9eXf8FL317IkN6p0c+gI+ddaGbWSrwj5w83NIm59wCYAFAbm6urkgt4rGVWw+yYd8RfnbzBcyYEPmdrK2l1dyzaD23PbeGF++dwAXZGRHP4FcdWeUyGBgEbDKzvUA2sNHM+oQymIiEXlNzC/NWFHNeZhrTx2d7kmFUv24snTOJ1OQEZvx2LWt3H/Ykhx+ddaE75z53zvV2zuU453KAEmCcc64s5OlEJKRe31jCzvLjzJ06nMQE71Yt5/RKY+mcyfTNSOGeRetZufWgZ1n8pD3LFl8F1gDDzazEzL4d/lgiEmp1Dc3MX7mDi87tztTzvf+Duk9GCkvun8TIvt2Y8/IG3thY4nWkmNeeVS4z2vh4TsjSiEjYLF69l7LqEzxx+0W0tZghUnqkJfPKdyZy/0v5PLJkE1W1jdz3tUFex4pZOlNUJA5U1Tbw9KqdfGNEby457xyv4/wP6Z0TWTTrYqad34d/fXsrv1q5Hee0fqIjVOgiceDpVbs4Xt/E3GnDvY5yWp0TE3jyjrHclpvNf7y/g5++tcWTNfKxLqIXuBCRyAtU1bF49V5uHpvNiD7dvI5zRokJnfj5LRfSPTWZBR/t5mhdI49PH0OShy/exhoVuojPzV+5HYBHrh7mcZK2mRk/vmYE3VOTmLe8mOoTTTx95zhSkhK8jhYT9KtPxMeKyqp5fWMJMycNpH/32DjV3sx48PIh/L+bRvNhcTn3LFxP9YlGr2PFBBW6iI89vryY9M6JPHj5EK+jnLU7Jw7kP24fS8H+I9z+3FoqjtV7HSnqqdBFfGrd7sO8X1TOA5cPpkdastdxOuSbY/rx/MyL2XOohtueW0PJkVqvI0U1FbqIDznneGx5EVndOnPv5Nhe133ZsExe/s4EDh+v59Zn1rDj4DGvI0UtFbqID63YcpCCL6p4eMowuiTH/guK4wf25LX7J9HsHLc9t4ZN+6u8jhSVVOgiPnNyAFcRgzPTuNWjAVzhMLLvyaFe6SmJ3PHbtazeecjrSFFHhS7iM0s3lLC7ooa500Z4OoArHAaec3KoV3aPVGa98Ckrtmgm4Kn89X9bJM7VNTQz/73tjBvQnatHZXkdJyyyuqXw2v2XcH7/bjzw8gb+mL/f60hRQ4Uu4iMvrN7Dwep6Hr1mZNQM4AqH7qknh3pdOqQXf7/0M57/z91eR4oKKnQRnzhS08Azq3YxZWRvJgzq6XWcsEtNTuT5mblce0Ff/v3P2/jFiuK4H+qlU/9FfOLpVTupqW/i76eO8DpKxHROTOA/Zoyla0oiT364k6q6Bv71+tF06uTfv06+igpdxAdKjtTy4up93DIum+F9unodJ6ISOhk/u/kCuqcm8+xfd3G0rolfTh9DcmL8HYBQoYv4wPyVO8Dg4auifwBXOJgZj7YO9XrsnSKOnWjkmTvH+2IN/tmIv19hIj5TVFbNGwUl3Ds5h34xMoArXOZcNpjHbr6Aj7ZXcPfCdRyti6+hXip0kRg3b3kxXTsn8sDlg72OEhVunzCAJ+8Yx6aSKm5fsJbyYye8jhQx7blI9CIzKzezzafc97iZFZnZZ2a2zMy6hzemiJzO2t2H+aConAevGEL31NgcwBUOf3tBXxbNuph9h2uY/uwa9lfGx1Cv9uyhLwamfem+lcBo59yFwHbgxyHOJSJtcM7x2DtF9OmWwqzJOV7HiTpfH5rJy9+ZSFVtI7c+u5rtcTDUq80XRZ1zH5lZzpfue/eUd9cCt4Y2loi0ZcWWMgr3VzHvlgt1RZ8zGDegB0vun8TdC9dx23Nr+LcbRtPDo79kRvXrRs8wjzEOxSqX+4DXzvRBM5sNzAYYMGBACDYnIk3NLcxbXszQ3uncPK6/13Gi2vA+XXn9gcnctXAd33+1wLMci++9mMuH9w7rNoIqdDP7J6AJeOVMj3HOLQAWAOTm5sb3aVwiIbIkv4Tdh2r47T25vhvAFQ7n9kzlzz/4OtsOVHuWYVjv8J8f0OFCN7NZwHXAlS7ez7cViaDahiaeeG87uQN7MGVkePf4/CS9cyIX5/h7JEKHCt3MpgFzgcucc/Hx8rFIlHjhk72UH6vn6TvH+XoAl5y99ixbfBVYAww3sxIz+zbwJNAVWGlmhWb2bJhzighQWdPAs6t2cdWoLHJ9vrcpZ689q1xmnObuhWHIIiJteOrDndQ0NDF36nCvo0gU0qspIjFif2UtL63Zx63jsxmaFV8DuKR9VOgiMWL+yu2YwUNT4nMAl7RNhS4SA7aWVrOsMMCsSzWAS85MhS4SA+atKKJr50QevGyI11EkiqnQRaLc6l2HWFVcwfeuGEJGapLXcSSKqdBFophzjp8vL6ZvRgozNYBL2qBCF4liyzeXsWl/FQ9fNUwDuKRNKnSRKNXY3MLjK4oZlpXOLeOyvY4jMUCFLhKlluTvZ/ehGuZOHUFCnF7FXs6OCl0kCp0cwLWDi3N6cKUGcEk7qdBFotCij/dQcayeR68ZoQFc0m4qdJEoU1nTwLN/3c3Vo7IYP1ADuKT9VOgiUebJD3ZS29DE3GkawCVnR4UuEkX2V9by0tq93JZ7LkMicIUb8RcVukgU+dXK7XQy0wAu6RAVukiU2FJ6lLzCAPd9bRB9MlK8jiMxSIUuEiXmLS+mW0oScy4b7HUUiVEqdJEosHrnIf66vYK/u2IIGV00gEs6RoUu4jHnHI8tL6JfRgp3TxrodRyJYe25SPQiMys3s82n3NfTzFaa2Y7Wtz3CG1PEv/7yeRmflRzlkauHawCXBKU9e+iLgWlfuu9R4H3n3FDg/db3ReQsnRzAVcTwrK7cNLa/13EkxrVZ6M65j4DKL919A/Bi6+0XgRtDnEskLvzh0/3sPVzLP1wzXAO4JGgdPYae5Zw70Hq7DMgKUR6RuNHY3MJv3t/BhEE9uWK4BnBJ8IJ+UdQ55wB3po+b2Wwzyzez/IqKimA3J+IbH+84RPmxer779fM0gEtCoqOFftDM+gK0vi0/0wOdcwucc7nOudzMzMwObk7Ef5YVBOiRmsRlw/RzIaHR0UJ/C5jZensm8GZo4ojEh+P1Tby7tYzrLuxHcqJWD0totGfZ4qvAGmC4mZWY2beBx4CrzGwHMKX1fRFppxWbyzjR2MKNWtkiIZTY1gOcczPO8KErQ5xFJG7kFQYY0DOVcQO6ex1FfER/64lE2MHqE3yy8xA3ju2vF0MlpFToIhH2p02ltDi48aJ+XkcRn1Ghi0TYsoIAY87tznmZ6V5HEZ9RoYtE0PaDx9hSWs1N2juXMFChi0RQXkGAhE7GdWNU6BJ6KnSRCGlpcbxZWMrfDO1Fr/TOXscRH1Khi0TIp3srCVTVae25hI0KXSRC8goDpCUncPWoPl5HEZ9SoYtEwInGZt7+7ABTR/ehS7IuYiHhoUIXiYBVxeUcO9Gki1hIWKnQRSJgWUGAzK6dmTy4l9dRxMdU6CJhVlXbwIdFFdwwpp+uSiRhpUIXCbO/fF5GQ7MmK0r4qdBFwiyvIMDQ3umc36+b11HE51ToImG0v7KW9XsrNVlRIkKFLhJGb20qBeB6neovEaBCFwkT5xxvbCxhQk5Pzu2Z6nUciQMqdJEw2VJaza6KGr0YKhGjQhcJk2UFAZITOnHtBX29jiJxIqhCN7OHzWyLmW02s1fNLCVUwURiWVNzC29tKuWKEZlkpCZ5HUfiRIcL3cz6Az8Acp1zo4EE4PZQBROJZat3HabiWL1O9ZeICvaQSyLQxcwSgVSgNPhIIrEvryBAt5RELh/e2+soEkc6XOjOuQDwC+AL4ABw1Dn3bqiCicSq2oYmlm8p49oL+5KSpMmKEjnBHHLpAdwADAL6AWlmdtdpHjfbzPLNLL+ioqLjSUVixMqtB6ltaObGi3S4RSIrmEMuU4A9zrkK51wj8AYw+csPcs4tcM7lOudyMzMzg9icSGxYVhCgf/cuXJzT0+soEmeCKfQvgEvMLNVOntN8JbAtNLFEYlPFsXr+c8chbrioH500WVEiLJhj6OuApcBG4PPWr7UgRLlEYtLbn5XS3OK0ukU8kRjMJzvnfgL8JERZRGJeXkGA8/t1Y2hWV6+jSBzSmaIiIbKr4jibSo5q71w8o0IXCZE3CwJ0MvimJiuKR1ToIiHgnCOvsJRLh/Qiq5smYIg3VOgiIbDxiyq+qKzV2nPxlApdJATyCgKkJHVi6ug+XkeROKZCFwlSQ1MLb39WytWj+pDeOaiFYyJBUaGLBOmj7RUcqW3U6hbxnApdJEjLCgOck5bM14b28jqKxDkVukgQqk808t7Wg3xzTD+SEvTjJN7Sd6BIEJZvLqO+qUXXDZWooEIXCUJeQYBBvdIYk53hdRQRFbpIRx04Wsea3Ye58aL+nBw4KuItFbpIB71VWIpzcONYneov0UGFLtJBywoCjBvQnYHnpHkdRQRQoYt0yLYD1RSVHdPac4kqKnSRDsgrDJDYybj2Qh1ukeihQhc5Sy0tjjcLSrl8eCY905K9jiPy31ToImdp7Z7DlFWf0NpziToqdJGzlFcQIL1zIlNGZnkdReR/UKGLnIUTjc2883kZ14zuQ0pSgtdxRP6HoArdzLqb2VIzKzKzbWY2KVTBRKLR+9vKOVbfpNUtEpWCHd78a2C5c+5WM0sGUkOQSSRqLSsI0KdbChPPO8frKCL/S4f30M0sA/gbYCGAc67BOVcVqmAi0aaypoFVxeXccFE/EjrpVH+JPsEcchkEVAAvmFmBmT1vZv/rlDkzm21m+WaWX1FREcTmRLz1588P0NTitLpFolYwhZ4IjAOecc6NBWqAR7/8IOfcAudcrnMuNzMzM4jNiXgrryDAiD5dGdm3m9dRRE4rmEIvAUqcc+ta31/KyYIX8Z0vDteyYd8R7Z1LVOtwoTvnyoD9Zja89a4rga0hSSUSZfIKA5jB9WN0qr9Er2BXuXwfeKV1hctu4N7gI4lEF+cceQUBJg7qSb/uXbyOI3JGQRW6c64QyA1RFpGo9FnJUXYfquH+y87zOorIV9KZoiJtWFYQIDmxE9NG9/U6ishXUqGLfIXG5hb+tKmUKSN7k9Elyes4Il9JhS7yFT7eeYjDNQ3ceJFWt0j0U6GLfIW8ggDdU5O4fHhvr6OItEmFLnIGx+ubWLGljGsv6Etyon5UJPrpu1TkDN7dUsaJxhZNVpSYoUIXOYNlBQGye3Rh/MAeXkcRaRcVushplFef4JOdh7hpbH/MNFlRYoMKXeQ03tpUSouDG7S6RWKICl3kNPIKA1yYncGQ3uleRxFpNxW6yJfsOHiMzYFqrT2XmKNCF/mSvMIACZ2Mb2qyosQYFbrIKVpaHHkFpXxtSC8yu3b2Oo7IWVGhi5wif98RAlV1WnsuMUmFLnKKvMIAqckJXH1+ltdRRM6aCl2kVX1TM3/+7ABTz+9DanKw134RiTwVukirVcUVHK1r1HVDJWap0EVa5RUE6JXemUsHn+N1FJEOUaGLAEfrGnl/WznXj+lHYoJ+LCQ2Bf2da2YJZlZgZm+HIpCIF975/AANzZqsKLEtFLsiPwS2heDriHhmWUGAwZlpjO7fzesoIh0WVKGbWTZwLfB8aOKIRF6gqo51eyo1WVFiXrB76E8Ac4GWMz3AzGabWb6Z5VdUVAS5OZHQ+93qvZhpsqLEvg4XupldB5Q75zZ81eOccwucc7nOudzMzMyObk4kLEqr6nhh9V5uGtufc3umeh1HJCjB7KFfClxvZnuBPwDfMLOXQ5JKJEKeeG87OHjkqmFeRxEJWocL3Tn3Y+dctnMuB7gd+MA5d1fIkomE2faDx1i6oYR7Jg0ku4f2ziX2acGtxK15y4tJS07ke1cM8TqKSEiEpNCdc6ucc9eF4muJRMKneyt5b9tB5lw+mB5pyV7HEQkJ7aFL3HHO8dg7RfTu2pn7Lh3kdRyRkFGhS9xZufUgG/Yd4eGrhtElOcHrOCIho0KXuNLU3MK8FcWcl5nG9PHZXscRCSkVusSV1zeWsLP8OHOnjtAQLvEdfUdL3KhraGb+yh2MHdCdqboikfiQCl3ixuLVeymrPsGj00ZoZov4kgpd4kJVbQNPr9rJlSN6M/E8XcBC/EmFLnHh6VW7OF7fxNxpI7yOIhI2KnTxvUBVHYtX7+XmsdkM79PV6zgiYaNCF9+bv3I7AI9crQFc4m8qdPG1orJqXt9YwsxJA+nfvYvXcUTCSoUuvvb48mLSOyfy4OUawCX+p0IX31q3+zDvF5XzgAZwSZxQoYsvOed4bHkRWd06c+9kDeCS+KBCF19aseUgBV9U8fAUDeCS+KFCF99pam7h8RVFDM5M41YN4JI4okIX31m6oYRdFTXMnaYBXBJf9N0uvlLX0Mz897YzbkB3rh6lAVwSX1To4isvrN7Dwep6Hr1mpAZwSdzpcKGb2blm9qGZbTWzLWb2w1AGEzlbR2oaeGbVLqaM7M2EQT29jiMScYlBfG4T8CPn3EYz6wpsMLOVzrmtIcomclaeXrWTmvom/n6qBnBJfOpwoTvnDgAHWm8fM7NtQH/AV4Ve19DMicZmT7bdrUsSCZ102KA9So7U8uLqfdwyTgO4JH4Fs4f+38wsBxgLrAvF14sWb39Wyo+WbKK+qcWT7Q/LSmfxvRPopxkkbZq/cgcYPHyVBnBJ/Aq60M0sHXgdeMg5V32aj88GZgMMGDAg2M1FzO/XfcE/5X3O+AE9uO7CvhHffn1TC09+sJNbn1nNS9+ZyODM9IhniBVFZdW8UVDC7K+fp19+EtfMOdfxTzZLAt4GVjjnftXW43Nzc11+fn6HtxcJzjme+esu5i0v5hsjevPUHeM8O9Nwc+Aos15Yj3Pw4n0TGN0/w5Mc0e6+xZ+Sv7eSj+ZeQfdUzWwR/zGzDc653LYeF8wqFwMWAtvaU+axwDnHz94pYt7yYm64qB/P3T3e09PGR/fP4I9zJpOSlMDtC9aydvdhz7JEq7W7D/NBUTkPXjFEZS5xL5h16JcCdwPfMLPC1n9/G6JcEdfU3MI/vP4ZCz7azcxJA5l/20UkRcFZhoN6pbH0gUn0yUhh5qL1vLf1oNeRooZzjsfeKaJPtxRmTc7xOo6I5zrcWM65j51z5py70Dl3Ueu/v4QyXKTUNzXzd78vYEl+CT+4cig/vf58OkXR6pK+GV1Ycv8kRvTpyv0vb2BZQYnXkaLCii1lFO6v4pGrhpGSpAFcIt7vgnqspr6J+xZ/yvItZfzzdaN45KphUXmGYc+0ZF757iVMHNSTh1/bxOJP9ngdyVNNzS3MW17M0N7p3Dyuv9dxRKJCXBf6kZoG7nx+HWt3V/LL6WO472vRPTc7vXMii2ZdzNTzs/jpn7byxHvbCeZF7Vi2JL+E3Yc0gEvkVHH7k1B29AS3PbeGrQeqefau8dwSI2NWU5ISeOqOcUwfn80T7+3gX/60lZaW+Cr12oYmnnhvO7kDezBlZG+v44hEjZCcWBRr9h6q4a6F66iqbeTFeycwafA5Xkc6K4kJnZh364VkdEni+Y/3cLSukXm3XhgVL+JGwguf7KX8WD1P3zkuKg+PiXgl7gp9a2k19yxaT4tzvPrdS7ggOzbXdpsZ/3TtSHqkJfP4imKOnWjkyTvG+f7FwcqaBp5dtYurRmWRm6MBXCKnio9dulb5eyv51oI1JCUYS+6fFLNl/l/MjO9dMYR/u3E07xeVc8+i9VSfaPQ6Vlg99eFOahqamDt1uNdRRKJO3BT6h8Xl3LVwHZnpnVn6wGSG9PbPqfR3XzKQX98+lo37jjBjwVoOHa/3OlJY7K+s5aU1+7h1fDZDszSAS+TL4qLQ3ywM8N0X8xnSO50lcybR34fzPq4f04/fzsxlV8Vxbnt2DYGqOq8jhdz8ldsxg4emaACXyOn4vtBfWruPh14rZPzAHrz63Uvold7Z60hhc8Xw3rz87YlUHK/n1mdWs7P8uNeRQmZraTXLCgPMujRHA7hEzsC3he6c48kPdvB/8zZz5YjevHjfBLqmJHkdK+xyc3ry2uxJNDY7bntuDZ+VVHkdKSTmrSiia+dEHrxsiNdRRKKWLwu9pcXx73/exi/e3c5NY/vzzF3jfb/641Sj+nVj6ZxJpCYnMGPBWlbvOuR1pKCs3nWIVcUVfO+KIWSk+v+XskhH+a7Qm5pbmPv6Zyz8eA+zJufwy+lj4mZ99qlyeqWxdM5k+vfowqwXPuXdLWVeR+oQ5xw/f6eIvhkpzNQALpGv5KumO9HYzIOvbGTphhIemjKUn3xzVFQN2Yq0PhkpLLl/EqP6duOB1v8useadzWVsKjnKwxrAJdIm3xT68fom7n3hU97depCffnMUD02JziFbkdY9NZlXvjORSeedw//54yYWfhw7Q70am1t4fEUxw7LSuWVcbIxmEPGSLwq9sqaBO367lvV7K5n/rTHMujS6h2xFWlrnRBbOyuWa0X34t7e38st3i2NiqNdrn+5nz6Ea5k4doYtli7RDzBf6gaN1TH92NcVlx3jurvHcNFZ7cqfTOTGBJ+8Yx7dyz+U3H+zkn9/cEtVDvWrqm3jivR1cnNODKzWAS6RdYnqWy+6K49y9cD3VdY387r4JTDwvtoZsRVpCJ+OxWy6ge1oSz/11N9UnGvlFlL5ovOjjPRw6Xs9zd2sAl0h7xWyhbw4cZeai9QC8OvsSXUC5ncyMH18zku5dkvn58iKOnWjy9ELYp1NZ08BzH+3m6lFZjB+oAVwi7RV9u2btsH5PJTMWrKVzYif+OGeSyrwDHrh8MD+7+QI+LC7nnkXrOFoXPUO9nvxgJ7UNTcydpgFcImcjqEI3s2lmVmxmO83s0VCF+iofFB3k7oXr6N3t5JCt8zL9M2Qr0mZMGMBvZoylcH8VMxaspeKY90O99lfW8tLavdyWey5DemsAl8jZ6HChm1kC8BRwDTAKmGFmo0IV7HTyCgLM/t0GhmV1Zcn9kzTTIwSuu7Afz8+8mD2Hapj+7Gr2V9Z6mudXK7fTyUwDuEQ6IJg99AnATufcbudcA/AH4IbQxPrfXly9l4deKyQ3pwe//+5EzvHxkK1Iu2xYJi9/ZyKVNQ1Mf3YNOw4e8yTHltKj5BUGuO9rg+iTkeJJBpFYFsyLov2B/ae8XwJMDC7O6T314U4eX1HMlJFZPHnHWJ0xGAbjB/ZgyZxJ3L1wPTc+9Yknf/0crmmgW0oScy4bHPFti/hB2Fe5mNlsYDbAgAEDOvQ1BvVKY/r4bH528wW6wnsYjejTjdfnTObX7++grrEp4tsfCnzr4gFkdNEALpGOsI6eMWhmk4CfOuemtr7/YwDn3M/O9Dm5ubkuPz+/Q9sTEYlXZrbBOZfb1uOC2d39FBhqZoPMLBm4HXgriK8nIiJB6PAhF+dck5n9HbACSAAWOee2hCyZiIiclaCOoTvn/gL8JURZREQkCHqFUUTEJ1ToIiI+oUIXEfEJFbqIiE+o0EVEfKLDJxZ1aGNmFcC+Dn56L+BQCOPEAj3n+KDnHB+Cec4DnXOZbT0oooUeDDPLb8+ZUn6i5xwf9JzjQySesw65iIj4hApdRMQnYqnQF3gdwAN6zvFBzzk+hP05x8wxdBER+WqxtIcuIiJfISYK3YuLUXvJzM41sw/NbKuZbTGzH3qdKRLMLMHMCszsba+zRIKZdTezpWZWZGbbWq8x4Gtm9nDr9/RmM3vVzHx3rUEzW2Rm5Wa2+ZT7eprZSjPb0fq2Rzi2HfWF7sXFqKNAE/Aj59wo4BLge3HwnAF+CGzzOkQE/RpY7pwbAYzB58/dzPoDPwBynXOjOTl2+3ZvU4XFYmDal+57FHjfOTcUeL/1/ZCL+kInwhejjgbOuQPOuY2tt49x8ge9v7epwsvMsoFrgee9zhIJZpYB/A2wEMA51+Ccq/I2VUQkAl3MLBFIBUo9zhNyzrmPgMov3X0D8GLr7ReBG8Ox7Vgo9NNdjNrX5XYqM8sBxgLrvE0Sdk8Ac4EWr4NEyCCgAnih9TDT82aW5nWocHLOBYBfAF8AB4Cjzrl3vU0VMVnOuQOtt8uArHBsJBYKPW6ZWTrwOvCQc67a6zzhYmbXAeXOuQ1eZ4mgRGAc8IxzbixQQ5j+DI8WrceNb+DkL7N+QJqZ3eVtqshzJ5cWhmV5YSwUegA495T3s1vv8zUzS+Jkmb/inHvD6zxhdilwvZnt5eQhtW+Y2cveRgq7EqDEOfdff3kt5WTB+9kUYI9zrsI51wi8AUz2OFOkHDSzvgCtb8vDsZFYKPS4uxi1mRknj61uc879yus84eac+7FzLts5l8PJ/78fOOd8vefmnCsD9pvZ8Na7rgS2ehgpEr4ALjGz1Nbv8Svx+QvBp3gLmNl6eybwZjg2EtQ1RSMhTi9GfSlwN/C5mRW23vePrddwFf/4PvBK647KbuBej/OElXNunZktBTZyciVXAT48Y9TMXgUuB3qZWQnwE+AxYImZfZuTE2cC8EOQAAAAPklEQVRvC8u2daaoiIg/xMIhFxERaQcVuoiIT6jQRUR8QoUuIuITKnQREZ9QoYuI+IQKXUTEJ1ToIiI+8f8B39K0BBgxAuwAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xabf086d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pylab as py\n",
    "import scipy as scipy\n",
    "import matplotlib.pyplot as plt\n",
    "import scipy.fftpack\n",
    "import numpy.fft\n",
    "\n",
    "\n",
    "fig1 = plt.figure()\n",
    "ax1 = fig1.gca()\n",
    "plt.plot(filt)\n",
    "\n",
    "fig2 = plt.figure()\n",
    "ax2 = fig2.gca()\n",
    "plt.plot(out_buffer)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FFT transformation, view the waveform\n",
    "进行FFT变换，查看波形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/lib/python3/dist-packages/numpy/core/numeric.py:531: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  return array(a, dtype, copy=False, order=order)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0xabd9ba90>]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xad430a10>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "out = scipy.fftpack.fft(actualfilt)\n",
    "plt.plot(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module matplotlib.pyplot in matplotlib:\n",
      "\n",
      "NAME\n",
      "    matplotlib.pyplot\n",
      "\n",
      "DESCRIPTION\n",
      "    `matplotlib.pyplot` is a state-based interface to matplotlib. It provides\n",
      "    a MATLAB-like way of plotting.\n",
      "    \n",
      "    pyplot is mainly intended for interactive plots and simple cases of programmatic\n",
      "    plot generation::\n",
      "    \n",
      "        import numpy as np\n",
      "        import matplotlib.pyplot as plt\n",
      "    \n",
      "        x = np.arange(0, 5, 0.1)\n",
      "        y = np.sin(x)\n",
      "        plt.plot(x, y)\n",
      "    \n",
      "    The object-oriented API is recommended for more complex plots.\n",
      "\n",
      "FUNCTIONS\n",
      "    acorr(x, hold=None, data=None, **kwargs)\n",
      "        Plot the autocorrelation of `x`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        x : sequence of scalar\n",
      "        \n",
      "        hold : boolean, optional, *deprecated*, default: True\n",
      "        \n",
      "        detrend : callable, optional, default: `mlab.detrend_none`\n",
      "            x is detrended by the `detrend` callable. Default is no\n",
      "            normalization.\n",
      "        \n",
      "        normed : boolean, optional, default: True\n",
      "            if True, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : boolean, optional, default: True\n",
      "            if True, Axes.vlines is used to plot the vertical lines from the\n",
      "            origin to the acorr. Otherwise, Axes.plot is used.\n",
      "        \n",
      "        maxlags : integer, optional, default: 10\n",
      "            number of lags to show. If None, will return all 2 * len(x) - 1\n",
      "            lags.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        (lags, c, line, b) : where:\n",
      "        \n",
      "          - `lags` are a length 2`maxlags+1 lag vector.\n",
      "          - `c` is the 2`maxlags+1 auto correlation vectorI\n",
      "          - `line` is a `~matplotlib.lines.Line2D` instance returned by\n",
      "            `plot`.\n",
      "          - `b` is the x-axis.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        linestyle : `~matplotlib.lines.Line2D` prop, optional, default: None\n",
      "            Only used if usevlines is False.\n",
      "        \n",
      "        marker : string, optional, default: 'o'\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with :func:`numpy.correlate` with\n",
      "        `mode` = 2.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    angle_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=None, data=None, **kwargs)\n",
      "        Plot the angle spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          angle_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                         pad_to=None, sides='default', **kwargs)\n",
      "        \n",
      "        Compute the angle spectrum (wrapped phase spectrum) of *x*.\n",
      "        Data is padded to a length of *pad_to* and the windowing function\n",
      "        *window* is applied to the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the angle spectrum in radians (real valued)\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*\n",
      "        \n",
      "        line : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`angle_spectrum` plots the magnitudes of the corresponding\n",
      "            frequencies.\n",
      "        \n",
      "        :func:`phase_spectrum`\n",
      "            :func:`phase_spectrum` plots the unwrapped version of this\n",
      "            function.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the angle spectrum of segments within the\n",
      "            signal in a colormap.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    annotate(*args, **kwargs)\n",
      "        Annotate the point ``xy`` with text ``s``.\n",
      "        \n",
      "        Additional kwargs are passed to `~matplotlib.text.Text`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        s : str\n",
      "            The text of the annotation\n",
      "        \n",
      "        xy : iterable\n",
      "            Length 2 sequence specifying the *(x,y)* point to annotate\n",
      "        \n",
      "        xytext : iterable, optional\n",
      "            Length 2 sequence specifying the *(x,y)* to place the text\n",
      "            at.  If None, defaults to ``xy``.\n",
      "        \n",
      "        xycoords : str, Artist, Transform, callable or tuple, optional\n",
      "        \n",
      "            The coordinate system that ``xy`` is given in.\n",
      "        \n",
      "            For a `str` the allowed values are:\n",
      "        \n",
      "            =================   ===============================================\n",
      "            Property            Description\n",
      "            =================   ===============================================\n",
      "            'figure points'     points from the lower left of the figure\n",
      "            'figure pixels'     pixels from the lower left of the figure\n",
      "            'figure fraction'   fraction of figure from lower left\n",
      "            'axes points'       points from lower left corner of axes\n",
      "            'axes pixels'       pixels from lower left corner of axes\n",
      "            'axes fraction'     fraction of axes from lower left\n",
      "            'data'              use the coordinate system of the object being\n",
      "                                annotated (default)\n",
      "            'polar'             *(theta,r)* if not native 'data' coordinates\n",
      "            =================   ===============================================\n",
      "        \n",
      "            If a `~matplotlib.artist.Artist` object is passed in the units are\n",
      "            fraction if it's bounding box.\n",
      "        \n",
      "            If a `~matplotlib.transforms.Transform` object is passed\n",
      "            in use that to transform ``xy`` to screen coordinates\n",
      "        \n",
      "            If a callable it must take a\n",
      "            `~matplotlib.backend_bases.RendererBase` object as input\n",
      "            and return a `~matplotlib.transforms.Transform` or\n",
      "            `~matplotlib.transforms.Bbox` object\n",
      "        \n",
      "            If a `tuple` must be length 2 tuple of str, `Artist`,\n",
      "            `Transform` or callable objects.  The first transform is\n",
      "            used for the *x* coordinate and the second for *y*.\n",
      "        \n",
      "            See :ref:`plotting-guide-annotation` for more details.\n",
      "        \n",
      "            Defaults to ``'data'``\n",
      "        \n",
      "        textcoords : str, `Artist`, `Transform`, callable or tuple, optional\n",
      "            The coordinate system that ``xytext`` is given, which\n",
      "            may be different than the coordinate system used for\n",
      "            ``xy``.\n",
      "        \n",
      "            All ``xycoords`` values are valid as well as the following\n",
      "            strings:\n",
      "        \n",
      "            =================   =========================================\n",
      "            Property            Description\n",
      "            =================   =========================================\n",
      "            'offset points'     offset (in points) from the *xy* value\n",
      "            'offset pixels'     offset (in pixels) from the *xy* value\n",
      "            =================   =========================================\n",
      "        \n",
      "            defaults to the input of ``xycoords``\n",
      "        \n",
      "        arrowprops : dict, optional\n",
      "            If not None, properties used to draw a\n",
      "            `~matplotlib.patches.FancyArrowPatch` arrow between ``xy`` and\n",
      "            ``xytext``.\n",
      "        \n",
      "            If `arrowprops` does not contain the key ``'arrowstyle'`` the\n",
      "            allowed keys are:\n",
      "        \n",
      "            ==========   ======================================================\n",
      "            Key          Description\n",
      "            ==========   ======================================================\n",
      "            width        the width of the arrow in points\n",
      "            headwidth    the width of the base of the arrow head in points\n",
      "            headlength   the length of the arrow head in points\n",
      "            shrink       fraction of total length to 'shrink' from both ends\n",
      "            ?            any key to :class:`matplotlib.patches.FancyArrowPatch`\n",
      "            ==========   ======================================================\n",
      "        \n",
      "            If the `arrowprops` contains the key ``'arrowstyle'`` the\n",
      "            above keys are forbidden.  The allowed values of\n",
      "            ``'arrowstyle'`` are:\n",
      "        \n",
      "            ============   =============================================\n",
      "            Name           Attrs\n",
      "            ============   =============================================\n",
      "            ``'-'``        None\n",
      "            ``'->'``       head_length=0.4,head_width=0.2\n",
      "            ``'-['``       widthB=1.0,lengthB=0.2,angleB=None\n",
      "            ``'|-|'``      widthA=1.0,widthB=1.0\n",
      "            ``'-|>'``      head_length=0.4,head_width=0.2\n",
      "            ``'<-'``       head_length=0.4,head_width=0.2\n",
      "            ``'<->'``      head_length=0.4,head_width=0.2\n",
      "            ``'<|-'``      head_length=0.4,head_width=0.2\n",
      "            ``'<|-|>'``    head_length=0.4,head_width=0.2\n",
      "            ``'fancy'``    head_length=0.4,head_width=0.4,tail_width=0.4\n",
      "            ``'simple'``   head_length=0.5,head_width=0.5,tail_width=0.2\n",
      "            ``'wedge'``    tail_width=0.3,shrink_factor=0.5\n",
      "            ============   =============================================\n",
      "        \n",
      "            Valid keys for `~matplotlib.patches.FancyArrowPatch` are:\n",
      "        \n",
      "            ===============  ==================================================\n",
      "            Key              Description\n",
      "            ===============  ==================================================\n",
      "            arrowstyle       the arrow style\n",
      "            connectionstyle  the connection style\n",
      "            relpos           default is (0.5, 0.5)\n",
      "            patchA           default is bounding box of the text\n",
      "            patchB           default is None\n",
      "            shrinkA          default is 2 points\n",
      "            shrinkB          default is 2 points\n",
      "            mutation_scale   default is text size (in points)\n",
      "            mutation_aspect  default is 1.\n",
      "            ?                any key for :class:`matplotlib.patches.PathPatch`\n",
      "            ===============  ==================================================\n",
      "        \n",
      "            Defaults to None\n",
      "        \n",
      "        annotation_clip : bool, optional\n",
      "            Controls the visibility of the annotation when it goes\n",
      "            outside the axes area.\n",
      "        \n",
      "            If `True`, the annotation will only be drawn when the\n",
      "            ``xy`` is inside the axes. If `False`, the annotation will\n",
      "            always be drawn regardless of its position.\n",
      "        \n",
      "            The default is `None`, which behave as `True` only if\n",
      "            *xycoords* is \"data\".\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Annotation\n",
      "    \n",
      "    arrow(x, y, dx, dy, hold=None, **kwargs)\n",
      "        Add an arrow to the axes.\n",
      "        \n",
      "        Draws arrow on specified axis from (`x`, `y`) to (`x` + `dx`,\n",
      "        `y` + `dy`). Uses FancyArrow patch to construct the arrow.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : float\n",
      "            X-coordinate of the arrow base\n",
      "        y : float\n",
      "            Y-coordinate of the arrow base\n",
      "        dx : float\n",
      "            Length of arrow along x-coordinate\n",
      "        dy : float\n",
      "            Length of arrow along y-coordinate\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        a : FancyArrow\n",
      "            patches.FancyArrow object\n",
      "        \n",
      "        Other Parameters\n",
      "        -----------------\n",
      "        Optional kwargs (inherited from FancyArrow patch) control the arrow\n",
      "        construction and properties:\n",
      "        \n",
      "        Constructor arguments\n",
      "          *width*: float (default: 0.001)\n",
      "            width of full arrow tail\n",
      "        \n",
      "          *length_includes_head*: [True | False] (default: False)\n",
      "            True if head is to be counted in calculating the length.\n",
      "        \n",
      "          *head_width*: float or None (default: 3*width)\n",
      "            total width of the full arrow head\n",
      "        \n",
      "          *head_length*: float or None (default: 1.5 * head_width)\n",
      "            length of arrow head\n",
      "        \n",
      "          *shape*: ['full', 'left', 'right'] (default: 'full')\n",
      "            draw the left-half, right-half, or full arrow\n",
      "        \n",
      "          *overhang*: float (default: 0)\n",
      "            fraction that the arrow is swept back (0 overhang means\n",
      "            triangular shape). Can be negative or greater than one.\n",
      "        \n",
      "          *head_starts_at_zero*: [True | False] (default: False)\n",
      "            if True, the head starts being drawn at coordinate 0\n",
      "            instead of ending at coordinate 0.\n",
      "        \n",
      "        Other valid kwargs (inherited from :class:`Patch`) are:\n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False]  or None for default \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `~.Figure` instance \n",
      "          fill: [True | False] \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The resulting arrow is affected by the axes aspect ratio and limits.\n",
      "        This may produce an arrow whose head is not square with its stem. To\n",
      "        create an arrow whose head is square with its stem, use\n",
      "        :meth:`annotate` for example::\n",
      "        \n",
      "            ax.annotate(\"\", xy=(0.5, 0.5), xytext=(0, 0),\n",
      "                arrowprops=dict(arrowstyle=\"->\"))\n",
      "    \n",
      "    autoscale(enable=True, axis='both', tight=None)\n",
      "        Autoscale the axis view to the data (toggle).\n",
      "        \n",
      "        Convenience method for simple axis view autoscaling.\n",
      "        It turns autoscaling on or off, and then,\n",
      "        if autoscaling for either axis is on, it performs\n",
      "        the autoscaling on the specified axis or axes.\n",
      "        \n",
      "        *enable*: [True | False | None]\n",
      "            True (default) turns autoscaling on, False turns it off.\n",
      "            None leaves the autoscaling state unchanged.\n",
      "        \n",
      "        *axis*: ['x' | 'y' | 'both']\n",
      "            which axis to operate on; default is 'both'\n",
      "        \n",
      "        *tight*: [True | False | None]\n",
      "            If True, set view limits to data limits;\n",
      "            if False, let the locator and margins expand the view limits;\n",
      "            if None, use tight scaling if the only artist is an image,\n",
      "            otherwise treat *tight* as False.\n",
      "            The *tight* setting is retained for future autoscaling\n",
      "            until it is explicitly changed.\n",
      "        \n",
      "        \n",
      "        Returns None.\n",
      "    \n",
      "    autumn()\n",
      "        set the default colormap to autumn and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    axes(*args, **kwargs)\n",
      "        Add an axes to the figure.\n",
      "        \n",
      "        The axes is added at position *rect* specified by:\n",
      "        \n",
      "        - ``axes()`` by itself creates a default full ``subplot(111)`` window axis.\n",
      "        \n",
      "        - ``axes(rect, facecolor='w')`` where *rect* = [left, bottom, width,\n",
      "          height] in normalized (0, 1) units.  *facecolor* is the background\n",
      "          color for the axis, default white.\n",
      "        \n",
      "        - ``axes(h)`` where *h* is an axes instance makes *h* the current\n",
      "          axis and the parent of *h* the current figure.\n",
      "          An :class:`~matplotlib.axes.Axes` instance is returned.\n",
      "        \n",
      "        =========   ==============   ==============================================\n",
      "        kwarg       Accepts          Description\n",
      "        =========   ==============   ==============================================\n",
      "        facecolor   color            the axes background color\n",
      "        frameon     [True|False]     display the frame?\n",
      "        sharex      otherax          current axes shares xaxis attribute\n",
      "                                     with otherax\n",
      "        sharey      otherax          current axes shares yaxis attribute\n",
      "                                     with otherax\n",
      "        polar       [True|False]     use a polar axes?\n",
      "        aspect      [str | num]      ['equal', 'auto'] or a number.  If a number\n",
      "                                     the ratio of y-unit/x-unit in screen-space.\n",
      "                                     Also see\n",
      "                                     :meth:`~matplotlib.axes.Axes.set_aspect`.\n",
      "        =========   ==============   ==============================================\n",
      "        \n",
      "        Examples:\n",
      "        \n",
      "        * :file:`examples/pylab_examples/axes_demo.py` places custom axes.\n",
      "        * :file:`examples/pylab_examples/shared_axis_demo.py` uses\n",
      "          *sharex* and *sharey*.\n",
      "    \n",
      "    axhline(y=0, xmin=0, xmax=1, hold=None, **kwargs)\n",
      "        Add a horizontal line across the axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar, optional, default: 0\n",
      "            y position in data coordinates of the horizontal line.\n",
      "        \n",
      "        xmin : scalar, optional, default: 0\n",
      "            Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      "            far right of the plot.\n",
      "        \n",
      "        xmax : scalar, optional, default: 1\n",
      "            Should be between 0 and 1, 0 being the far left of the plot, 1 the\n",
      "            far right of the plot.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,\n",
      "            with the exception of 'transform':\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        kwargs are passed to :class:`~matplotlib.lines.Line2D` and can be used\n",
      "        to control the line properties.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        * draw a thick red hline at 'y' = 0 that spans the xrange::\n",
      "        \n",
      "            >>> axhline(linewidth=4, color='r')\n",
      "        \n",
      "        * draw a default hline at 'y' = 1 that spans the xrange::\n",
      "        \n",
      "            >>> axhline(y=1)\n",
      "        \n",
      "        * draw a default hline at 'y' = .5 that spans the middle half of\n",
      "          the xrange::\n",
      "        \n",
      "            >>> axhline(y=.5, xmin=0.25, xmax=0.75)\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hlines : add horizontal lines in data coordinates\n",
      "        axhspan : add a horizontal span (rectangle) across the axis\n",
      "    \n",
      "    axhspan(ymin, ymax, xmin=0, xmax=1, hold=None, **kwargs)\n",
      "        Add a horizontal span (rectangle) across the axis.\n",
      "        \n",
      "        Draw a horizontal span (rectangle) from *ymin* to *ymax*.\n",
      "        With the default values of *xmin* = 0 and *xmax* = 1, this\n",
      "        always spans the xrange, regardless of the xlim settings, even\n",
      "        if you change them, e.g., with the :meth:`set_xlim` command.\n",
      "        That is, the horizontal extent is in axes coords: 0=left,\n",
      "        0.5=middle, 1.0=right but the *y* location is in data\n",
      "        coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        ymin : float\n",
      "               Lower limit of the horizontal span in data units.\n",
      "        ymax : float\n",
      "               Upper limit of the horizontal span in data units.\n",
      "        xmin : float, optional, default: 0\n",
      "               Lower limit of the vertical span in axes (relative\n",
      "               0-1) units.\n",
      "        xmax : float, optional, default: 1\n",
      "               Upper limit of the vertical span in axes (relative\n",
      "               0-1) units.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Polygon : `~matplotlib.patches.Polygon`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Polygon` properties.\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False]  or None for default \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `~.Figure` instance \n",
      "          fill: [True | False] \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axvspan : add a vertical span across the axes\n",
      "    \n",
      "    axis(*v, **kwargs)\n",
      "        Convenience method to get or set axis properties.\n",
      "        \n",
      "        Calling with no arguments::\n",
      "        \n",
      "          >>> axis()\n",
      "        \n",
      "        returns the current axes limits ``[xmin, xmax, ymin, ymax]``.::\n",
      "        \n",
      "          >>> axis(v)\n",
      "        \n",
      "        sets the min and max of the x and y axes, with\n",
      "        ``v = [xmin, xmax, ymin, ymax]``.::\n",
      "        \n",
      "          >>> axis('off')\n",
      "        \n",
      "        turns off the axis lines and labels.::\n",
      "        \n",
      "          >>> axis('equal')\n",
      "        \n",
      "        changes limits of *x* or *y* axis so that equal increments of *x*\n",
      "        and *y* have the same length; a circle is circular.::\n",
      "        \n",
      "          >>> axis('scaled')\n",
      "        \n",
      "        achieves the same result by changing the dimensions of the plot box instead\n",
      "        of the axis data limits.::\n",
      "        \n",
      "          >>> axis('tight')\n",
      "        \n",
      "        changes *x* and *y* axis limits such that all data is shown. If\n",
      "        all data is already shown, it will move it to the center of the\n",
      "        figure without modifying (*xmax* - *xmin*) or (*ymax* -\n",
      "        *ymin*). Note this is slightly different than in MATLAB.::\n",
      "        \n",
      "          >>> axis('image')\n",
      "        \n",
      "        is 'scaled' with the axis limits equal to the data limits.::\n",
      "        \n",
      "          >>> axis('auto')\n",
      "        \n",
      "        and::\n",
      "        \n",
      "          >>> axis('normal')\n",
      "        \n",
      "        are deprecated. They restore default behavior; axis limits are automatically\n",
      "        scaled to make the data fit comfortably within the plot box.\n",
      "        \n",
      "        if ``len(*v)==0``, you can pass in *xmin*, *xmax*, *ymin*, *ymax*\n",
      "        as kwargs selectively to alter just those limits without changing\n",
      "        the others.\n",
      "        \n",
      "          >>> axis('square')\n",
      "        \n",
      "        changes the limit ranges (*xmax*-*xmin*) and (*ymax*-*ymin*) of\n",
      "        the *x* and *y* axes to be the same, and have the same scaling,\n",
      "        resulting in a square plot.\n",
      "        \n",
      "        The xmin, xmax, ymin, ymax tuple is returned\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`xlim`, :func:`ylim`\n",
      "               For setting the x- and y-limits individually.\n",
      "    \n",
      "    axvline(x=0, ymin=0, ymax=1, hold=None, **kwargs)\n",
      "        Add a vertical line across the axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : scalar, optional, default: 0\n",
      "            x position in data coordinates of the vertical line.\n",
      "        \n",
      "        ymin : scalar, optional, default: 0\n",
      "            Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      "            top of the plot.\n",
      "        \n",
      "        ymax : scalar, optional, default: 1\n",
      "            Should be between 0 and 1, 0 being the bottom of the plot, 1 the\n",
      "            top of the plot.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~matplotlib.lines.Line2D`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,\n",
      "            with the exception of 'transform':\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        * draw a thick red vline at *x* = 0 that spans the yrange::\n",
      "        \n",
      "            >>> axvline(linewidth=4, color='r')\n",
      "        \n",
      "        * draw a default vline at *x* = 1 that spans the yrange::\n",
      "        \n",
      "            >>> axvline(x=1)\n",
      "        \n",
      "        * draw a default vline at *x* = .5 that spans the middle half of\n",
      "          the yrange::\n",
      "        \n",
      "            >>> axvline(x=.5, ymin=0.25, ymax=0.75)\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        vlines : add vertical lines in data coordinates\n",
      "        axvspan : add a vertical span (rectangle) across the axis\n",
      "    \n",
      "    axvspan(xmin, xmax, ymin=0, ymax=1, hold=None, **kwargs)\n",
      "        Add a vertical span (rectangle) across the axes.\n",
      "        \n",
      "        Draw a vertical span (rectangle) from `xmin` to `xmax`.  With\n",
      "        the default values of `ymin` = 0 and `ymax` = 1. This always\n",
      "        spans the yrange, regardless of the ylim settings, even if you\n",
      "        change them, e.g., with the :meth:`set_ylim` command.  That is,\n",
      "        the vertical extent is in axes coords: 0=bottom, 0.5=middle,\n",
      "        1.0=top but the y location is in data coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xmin : scalar\n",
      "            Number indicating the first X-axis coordinate of the vertical\n",
      "            span rectangle in data units.\n",
      "        xmax : scalar\n",
      "            Number indicating the second X-axis coordinate of the vertical\n",
      "            span rectangle in data units.\n",
      "        ymin : scalar, optional\n",
      "            Number indicating the first Y-axis coordinate of the vertical\n",
      "            span rectangle in relative Y-axis units (0-1). Default to 0.\n",
      "        ymax : scalar, optional\n",
      "            Number indicating the second Y-axis coordinate of the vertical\n",
      "            span rectangle in relative Y-axis units (0-1). Default to 1.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rectangle : matplotlib.patches.Polygon\n",
      "            Vertical span (rectangle) from (xmin, ymin) to (xmax, ymax).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs\n",
      "            Optional parameters are properties of the class\n",
      "            matplotlib.patches.Polygon.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        axhspan : add a horizontal span across the axes\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Draw a vertical, green, translucent rectangle from x = 1.25 to\n",
      "        x = 1.55 that spans the yrange of the axes.\n",
      "        \n",
      "        >>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)\n",
      "    \n",
      "    bar(*args, **kwargs)\n",
      "        Make a bar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "           bar(x, height, *, align='center', **kwargs)\n",
      "           bar(x, height, width, *, align='center', **kwargs)\n",
      "           bar(x, height, width, bottom, *, align='center', **kwargs)\n",
      "        \n",
      "        Make a bar plot with rectangles bounded by\n",
      "        \n",
      "        .. math::\n",
      "        \n",
      "           (x - width/2, x + width/2, bottom, bottom + height)\n",
      "        \n",
      "        (left, right, bottom and top edges) by default.  *x*,\n",
      "        *height*, *width*, and *bottom* can be either scalars or\n",
      "        sequences.\n",
      "        \n",
      "        The *align* and *orientation* kwargs control the interpretation of *x*\n",
      "        and *bottom*\n",
      "        \n",
      "        The *align* keyword-only argument controls if *x* is interpreted\n",
      "        as the center or the left edge of the rectangle.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : sequence of scalars\n",
      "            the x coordinates of the bars.\n",
      "        \n",
      "            *align* controls if *x* is the bar center (default) or\n",
      "            left edge.\n",
      "        \n",
      "        height : scalar or sequence of scalars\n",
      "            the height(s) of the bars\n",
      "        \n",
      "        width : scalar or array-like, optional\n",
      "            the width(s) of the bars\n",
      "            default: 0.8\n",
      "        \n",
      "        bottom : scalar or array-like, optional\n",
      "            the y coordinate(s) of the bars\n",
      "            default: None\n",
      "        \n",
      "        align : {'center', 'edge'}, optional, default: 'center'\n",
      "            If 'center', interpret the *x* argument as the coordinates\n",
      "            of the centers of the bars.  If 'edge', aligns bars by\n",
      "            their left edges\n",
      "        \n",
      "            To align the bars on the right edge pass a negative\n",
      "            *width* and ``align='edge'``\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        bars : matplotlib.container.BarContainer\n",
      "            Container with all of the bars + errorbars\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        color : scalar or array-like, optional\n",
      "            the colors of the bar faces\n",
      "        \n",
      "        edgecolor : scalar or array-like, optional\n",
      "            the colors of the bar edges\n",
      "        \n",
      "        linewidth : scalar or array-like, optional\n",
      "            width of bar edge(s). If None, use default\n",
      "            linewidth; If 0, don't draw edges.\n",
      "            default: None\n",
      "        \n",
      "        tick_label : string or array-like, optional\n",
      "            the tick labels of the bars\n",
      "            default: None\n",
      "        \n",
      "        xerr : scalar or array-like, optional\n",
      "            if not None, will be used to generate errorbar(s) on the bar chart\n",
      "            default: None\n",
      "        \n",
      "        yerr : scalar or array-like, optional\n",
      "            if not None, will be used to generate errorbar(s) on the bar chart\n",
      "            default: None\n",
      "        \n",
      "        ecolor : scalar or array-like, optional\n",
      "            specifies the color of errorbar(s)\n",
      "            default: None\n",
      "        \n",
      "        capsize : scalar, optional\n",
      "           determines the length in points of the error bar caps\n",
      "           default: None, which will take the value from the\n",
      "           ``errorbar.capsize`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        error_kw : dict, optional\n",
      "            dictionary of kwargs to be passed to errorbar method. *ecolor* and\n",
      "            *capsize* may be specified here rather than as independent kwargs.\n",
      "        \n",
      "        log : boolean, optional\n",
      "            If true, sets the axis to be log scale.\n",
      "            default: False\n",
      "        \n",
      "        orientation : {'vertical',  'horizontal'}, optional\n",
      "        \n",
      "            This is for internal use, please do not directly use this,\n",
      "            call `barh` instead.\n",
      "        \n",
      "            The orientation of the bars.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        barh: Plot a horizontal bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "        *xerr*, and *yerr* can be either scalars or sequences of\n",
      "        length equal to the number of bars.  This enables you to use\n",
      "        bar as the basis for stacked bar charts, or candlestick plots.\n",
      "        Detail: *xerr* and *yerr* are passed directly to\n",
      "        :meth:`errorbar`, so they can also have shape 2xN for\n",
      "        independent specification of lower and upper errors.\n",
      "        \n",
      "        Other optional kwargs:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False]  or None for default \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `~.Figure` instance \n",
      "          fill: [True | False] \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'bottom', 'color', 'ecolor', 'edgecolor', 'height', 'left', 'linewidth', 'tick_label', 'width', 'x', 'xerr', 'y', 'yerr'.\n",
      "            * All positional arguments.\n",
      "    \n",
      "    barbs(*args, **kw)\n",
      "        Plot a 2-D field of barbs.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          barb(U, V, **kw)\n",
      "          barb(U, V, C, **kw)\n",
      "          barb(X, Y, U, V, **kw)\n",
      "          barb(X, Y, U, V, C, **kw)\n",
      "        \n",
      "        Arguments:\n",
      "        \n",
      "          *X*, *Y*:\n",
      "            The x and y coordinates of the barb locations\n",
      "            (default is head of barb; see *pivot* kwarg)\n",
      "        \n",
      "          *U*, *V*:\n",
      "            Give the x and y components of the barb shaft\n",
      "        \n",
      "          *C*:\n",
      "            An optional array used to map colors to the barbs\n",
      "        \n",
      "        All arguments may be 1-D or 2-D arrays or sequences. If *X* and *Y*\n",
      "        are absent, they will be generated as a uniform grid.  If *U* and *V*\n",
      "        are 2-D arrays but *X* and *Y* are 1-D, and if ``len(X)`` and ``len(Y)``\n",
      "        match the column and row dimensions of *U*, then *X* and *Y* will be\n",
      "        expanded with :func:`numpy.meshgrid`.\n",
      "        \n",
      "        *U*, *V*, *C* may be masked arrays, but masked *X*, *Y* are not\n",
      "        supported at present.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *length*:\n",
      "            Length of the barb in points; the other parts of the barb\n",
      "            are scaled against this.\n",
      "            Default is 7.\n",
      "        \n",
      "          *pivot*: [ 'tip' | 'middle' | float ]\n",
      "            The part of the arrow that is at the grid point; the arrow rotates\n",
      "            about this point, hence the name *pivot*.  Default is 'tip'. Can\n",
      "            also be a number, which shifts the start of the barb that many\n",
      "            points from the origin.\n",
      "        \n",
      "          *barbcolor*: [ color | color sequence ]\n",
      "            Specifies the color all parts of the barb except any flags.  This\n",
      "            parameter is analagous to the *edgecolor* parameter for polygons,\n",
      "            which can be used instead. However this parameter will override\n",
      "            facecolor.\n",
      "        \n",
      "          *flagcolor*: [ color | color sequence ]\n",
      "            Specifies the color of any flags on the barb.  This parameter is\n",
      "            analagous to the *facecolor* parameter for polygons, which can be\n",
      "            used instead. However this parameter will override facecolor.  If\n",
      "            this is not set (and *C* has not either) then *flagcolor* will be\n",
      "            set to match *barbcolor* so that the barb has a uniform color. If\n",
      "            *C* has been set, *flagcolor* has no effect.\n",
      "        \n",
      "          *sizes*:\n",
      "            A dictionary of coefficients specifying the ratio of a given\n",
      "            feature to the length of the barb. Only those values one wishes to\n",
      "            override need to be included.  These features include:\n",
      "        \n",
      "                - 'spacing' - space between features (flags, full/half barbs)\n",
      "        \n",
      "                - 'height' - height (distance from shaft to top) of a flag or\n",
      "                  full barb\n",
      "        \n",
      "                - 'width' - width of a flag, twice the width of a full barb\n",
      "        \n",
      "                - 'emptybarb' - radius of the circle used for low magnitudes\n",
      "        \n",
      "          *fill_empty*:\n",
      "            A flag on whether the empty barbs (circles) that are drawn should\n",
      "            be filled with the flag color.  If they are not filled, they will\n",
      "            be drawn such that no color is applied to the center.  Default is\n",
      "            False\n",
      "        \n",
      "          *rounding*:\n",
      "            A flag to indicate whether the vector magnitude should be rounded\n",
      "            when allocating barb components.  If True, the magnitude is\n",
      "            rounded to the nearest multiple of the half-barb increment.  If\n",
      "            False, the magnitude is simply truncated to the next lowest\n",
      "            multiple.  Default is True\n",
      "        \n",
      "          *barb_increments*:\n",
      "            A dictionary of increments specifying values to associate with\n",
      "            different parts of the barb. Only those values one wishes to\n",
      "            override need to be included.\n",
      "        \n",
      "                - 'half' - half barbs (Default is 5)\n",
      "        \n",
      "                - 'full' - full barbs (Default is 10)\n",
      "        \n",
      "                - 'flag' - flags (default is 50)\n",
      "        \n",
      "          *flip_barb*:\n",
      "            Either a single boolean flag or an array of booleans.  Single\n",
      "            boolean indicates whether the lines and flags should point\n",
      "            opposite to normal for all barbs.  An array (which should be the\n",
      "            same size as the other data arrays) indicates whether to flip for\n",
      "            each individual barb.  Normal behavior is for the barbs and lines\n",
      "            to point right (comes from wind barbs having these features point\n",
      "            towards low pressure in the Northern Hemisphere.)  Default is\n",
      "            False\n",
      "        \n",
      "        Barbs are traditionally used in meteorology as a way to plot the speed\n",
      "        and direction of wind observations, but can technically be used to\n",
      "        plot any two dimensional vector quantity.  As opposed to arrows, which\n",
      "        give vector magnitude by the length of the arrow, the barbs give more\n",
      "        quantitative information about the vector magnitude by putting slanted\n",
      "        lines or a triangle for various increments in magnitude, as show\n",
      "        schematically below::\n",
      "        \n",
      "         :     /\\    \\\\\n",
      "         :    /  \\    \\\\\n",
      "         :   /    \\    \\    \\\\\n",
      "         :  /      \\    \\    \\\\\n",
      "         : ------------------------------\n",
      "        \n",
      "        .. note the double \\\\ at the end of each line to make the figure\n",
      "        .. render correctly\n",
      "        \n",
      "        The largest increment is given by a triangle (or \"flag\"). After those\n",
      "        come full lines (barbs). The smallest increment is a half line.  There\n",
      "        is only, of course, ever at most 1 half line.  If the magnitude is\n",
      "        small and only needs a single half-line and no full lines or\n",
      "        triangles, the half-line is offset from the end of the barb so that it\n",
      "        can be easily distinguished from barbs with a single full line.  The\n",
      "        magnitude for the barb shown above would nominally be 65, using the\n",
      "        standard increments of 50, 10, and 5.\n",
      "        \n",
      "        linewidths and edgecolors can be used to customize the barb.\n",
      "        Additional :class:`~matplotlib.collections.PolyCollection` keyword\n",
      "        arguments:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    barh(*args, **kwargs)\n",
      "        Make a horizontal bar plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "           bar(y, width, *, align='center', **kwargs)\n",
      "           bar(y, width, height, *, align='center', **kwargs)\n",
      "           bar(y, width, height, left, *, align='center', **kwargs)\n",
      "        \n",
      "        Make a horizontal bar plot with rectangles by default bounded by\n",
      "        \n",
      "        .. math::\n",
      "        \n",
      "           (left, left + width, y - height/2, y + height/2)\n",
      "        \n",
      "        (left, right, bottom and top edges) by default.  *y*, *width*,\n",
      "        *height*, and *left* can be either scalars or sequences.\n",
      "        \n",
      "        The *align* keyword-only argument controls if *y* is interpreted\n",
      "        as the center or the bottom edge of the rectangle.\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar or array-like\n",
      "            the y coordinate(s) of the bars\n",
      "        \n",
      "            *align* controls if *y* is the bar center (default)\n",
      "            or bottom edge.\n",
      "        \n",
      "        width : scalar or array-like\n",
      "            the width(s) of the bars\n",
      "        \n",
      "        height : sequence of scalars, optional, default: 0.8\n",
      "            the heights of the bars\n",
      "        \n",
      "        left : sequence of scalars\n",
      "            the x coordinates of the left sides of the bars\n",
      "        \n",
      "        align : {'center', 'edge'}, optional, default: 'center'\n",
      "            If 'center', interpret the *y* argument as the coordinates\n",
      "            of the centers of the bars.  If 'edge', aligns bars by\n",
      "            their bottom edges\n",
      "        \n",
      "            To align the bars on the top edge pass a negative\n",
      "            *height* and ``align='edge'``\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `matplotlib.patches.Rectangle` instances.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        color : scalar or array-like, optional\n",
      "            the colors of the bars\n",
      "        \n",
      "        edgecolor : scalar or array-like, optional\n",
      "            the colors of the bar edges\n",
      "        \n",
      "        linewidth : scalar or array-like, optional, default: None\n",
      "            width of bar edge(s). If None, use default\n",
      "            linewidth; If 0, don't draw edges.\n",
      "        \n",
      "        tick_label : string or array-like, optional, default: None\n",
      "            the tick labels of the bars\n",
      "        \n",
      "        xerr : scalar or array-like, optional, default: None\n",
      "            if not None, will be used to generate errorbar(s) on the bar chart\n",
      "        \n",
      "        yerr : scalar or array-like, optional, default: None\n",
      "            if not None, will be used to generate errorbar(s) on the bar chart\n",
      "        \n",
      "        ecolor : scalar or array-like, optional, default: None\n",
      "            specifies the color of errorbar(s)\n",
      "        \n",
      "        capsize : scalar, optional\n",
      "           determines the length in points of the error bar caps\n",
      "           default: None, which will take the value from the\n",
      "           ``errorbar.capsize`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        error_kw :\n",
      "            dictionary of kwargs to be passed to errorbar method. `ecolor` and\n",
      "            `capsize` may be specified here rather than as independent kwargs.\n",
      "        \n",
      "        log : boolean, optional, default: False\n",
      "            If true, sets the axis to be log scale\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        bar: Plot a vertical bar plot.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The optional arguments *color*, *edgecolor*, *linewidth*,\n",
      "        *xerr*, and *yerr* can be either scalars or sequences of\n",
      "        length equal to the number of bars.  This enables you to use\n",
      "        bar as the basis for stacked bar charts, or candlestick plots.\n",
      "        Detail: *xerr* and *yerr* are passed directly to\n",
      "        :meth:`errorbar`, so they can also have shape 2xN for\n",
      "        independent specification of lower and upper errors.\n",
      "        \n",
      "        Other optional kwargs:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False]  or None for default \n",
      "          capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color: matplotlib color spec\n",
      "          contains: a callable function \n",
      "          edgecolor or ec: mpl color spec, None, 'none', or 'auto' \n",
      "          facecolor or fc: mpl color spec, or None for default, or 'none' for no color \n",
      "          figure: a `~.Figure` instance \n",
      "          fill: [True | False] \n",
      "          gid: an id string \n",
      "          hatch: ['/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*'] \n",
      "          joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float or None for default \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float\n",
      "    \n",
      "    bone()\n",
      "        set the default colormap to bone and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    box(on=None)\n",
      "        Turn the axes box on or off.  *on* may be a boolean or a string,\n",
      "        'on' or 'off'.\n",
      "        \n",
      "        If *on* is *None*, toggle state.\n",
      "    \n",
      "    boxplot(x, notch=None, sym=None, vert=None, whis=None, positions=None, widths=None, patch_artist=None, bootstrap=None, usermedians=None, conf_intervals=None, meanline=None, showmeans=None, showcaps=None, showbox=None, showfliers=None, boxprops=None, labels=None, flierprops=None, medianprops=None, meanprops=None, capprops=None, whiskerprops=None, manage_xticks=True, autorange=False, zorder=None, hold=None, data=None)\n",
      "        Make a box and whisker plot.\n",
      "        \n",
      "        Make a box and whisker plot for each column of ``x`` or each\n",
      "        vector in sequence ``x``.  The box extends from the lower to\n",
      "        upper quartile values of the data, with a line at the median.\n",
      "        The whiskers extend from the box to show the range of the\n",
      "        data.  Flier points are those past the end of the whiskers.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : Array or a sequence of vectors.\n",
      "            The input data.\n",
      "        \n",
      "        notch : bool, optional (False)\n",
      "            If `True`, will produce a notched box plot. Otherwise, a\n",
      "            rectangular boxplot is produced. The notches represent the\n",
      "            confidence interval (CI) around the median. See the entry\n",
      "            for the ``bootstrap`` parameter for information regarding\n",
      "            how the locations of the notches are computed.\n",
      "        \n",
      "            .. note::\n",
      "        \n",
      "                In cases where the values of the CI are less than the\n",
      "                lower quartile or greater than the upper quartile, the\n",
      "                notches will extend beyond the box, giving it a\n",
      "                distinctive \"flipped\" appearance. This is expected\n",
      "                behavior and consistent with other statistical\n",
      "                visualization packages.\n",
      "        \n",
      "        sym : str, optional\n",
      "            The default symbol for flier points. Enter an empty string\n",
      "            ('') if you don't want to show fliers. If `None`, then the\n",
      "            fliers default to 'b+'  If you want more control use the\n",
      "            flierprops kwarg.\n",
      "        \n",
      "        vert : bool, optional (True)\n",
      "            If `True` (default), makes the boxes vertical. If `False`,\n",
      "            everything is drawn horizontally.\n",
      "        \n",
      "        whis : float, sequence, or string (default = 1.5)\n",
      "            As a float, determines the reach of the whiskers to the beyond the\n",
      "            first and third quartiles. In other words, where IQR is the\n",
      "            interquartile range (`Q3-Q1`), the upper whisker will extend to\n",
      "            last datum less than `Q3 + whis*IQR`). Similarly, the lower whisker\n",
      "            will extend to the first datum greater than `Q1 - whis*IQR`.\n",
      "            Beyond the whiskers, data\n",
      "            are considered outliers and are plotted as individual\n",
      "            points. Set this to an unreasonably high value to force the\n",
      "            whiskers to show the min and max values. Alternatively, set\n",
      "            this to an ascending sequence of percentile (e.g., [5, 95])\n",
      "            to set the whiskers at specific percentiles of the data.\n",
      "            Finally, ``whis`` can be the string ``'range'`` to force the\n",
      "            whiskers to the min and max of the data.\n",
      "        \n",
      "        bootstrap : int, optional\n",
      "            Specifies whether to bootstrap the confidence intervals\n",
      "            around the median for notched boxplots. If ``bootstrap`` is\n",
      "            None, no bootstrapping is performed, and notches are\n",
      "            calculated using a Gaussian-based asymptotic approximation\n",
      "            (see McGill, R., Tukey, J.W., and Larsen, W.A., 1978, and\n",
      "            Kendall and Stuart, 1967). Otherwise, bootstrap specifies\n",
      "            the number of times to bootstrap the median to determine its\n",
      "            95% confidence intervals. Values between 1000 and 10000 are\n",
      "            recommended.\n",
      "        \n",
      "        usermedians : array-like, optional\n",
      "            An array or sequence whose first dimension (or length) is\n",
      "            compatible with ``x``. This overrides the medians computed\n",
      "            by matplotlib for each element of ``usermedians`` that is not\n",
      "            `None`. When an element of ``usermedians`` is None, the median\n",
      "            will be computed by matplotlib as normal.\n",
      "        \n",
      "        conf_intervals : array-like, optional\n",
      "            Array or sequence whose first dimension (or length) is\n",
      "            compatible with ``x`` and whose second dimension is 2. When\n",
      "            the an element of ``conf_intervals`` is not None, the\n",
      "            notch locations computed by matplotlib are overridden\n",
      "            (provided ``notch`` is `True`). When an element of\n",
      "            ``conf_intervals`` is `None`, the notches are computed by the\n",
      "            method specified by the other kwargs (e.g., ``bootstrap``).\n",
      "        \n",
      "        positions : array-like, optional\n",
      "            Sets the positions of the boxes. The ticks and limits are\n",
      "            automatically set to match the positions. Defaults to\n",
      "            `range(1, N+1)` where N is the number of boxes to be drawn.\n",
      "        \n",
      "        widths : scalar or array-like\n",
      "            Sets the width of each box either with a scalar or a\n",
      "            sequence. The default is 0.5, or ``0.15*(distance between\n",
      "            extreme positions)``, if that is smaller.\n",
      "        \n",
      "        patch_artist : bool, optional (False)\n",
      "            If `False` produces boxes with the Line2D artist. Otherwise,\n",
      "            boxes and drawn with Patch artists.\n",
      "        \n",
      "        labels : sequence, optional\n",
      "            Labels for each dataset. Length must be compatible with\n",
      "            dimensions  of ``x``.\n",
      "        \n",
      "        manage_xticks : bool, optional (True)\n",
      "            If the function should adjust the xlim and xtick locations.\n",
      "        \n",
      "        autorange : bool, optional (False)\n",
      "            When `True` and the data are distributed such that the  25th and\n",
      "            75th percentiles are equal, ``whis`` is set to ``'range'`` such\n",
      "            that the whisker ends are at the minimum and maximum of the\n",
      "            data.\n",
      "        \n",
      "        meanline : bool, optional (False)\n",
      "            If `True` (and ``showmeans`` is `True`), will try to render\n",
      "            the mean as a line spanning the full width of the box\n",
      "            according to ``meanprops`` (see below). Not recommended if\n",
      "            ``shownotches`` is also True. Otherwise, means will be shown\n",
      "            as points.\n",
      "        \n",
      "        zorder : scalar, optional (None)\n",
      "            Sets the zorder of the boxplot.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        showcaps : bool, optional (True)\n",
      "            Show the caps on the ends of whiskers.\n",
      "        showbox : bool, optional (True)\n",
      "            Show the central box.\n",
      "        showfliers : bool, optional (True)\n",
      "            Show the outliers beyond the caps.\n",
      "        showmeans : bool, optional (False)\n",
      "            Show the arithmetic means.\n",
      "        capprops : dict, optional (None)\n",
      "            Specifies the style of the caps.\n",
      "        boxprops : dict, optional (None)\n",
      "            Specifies the style of the box.\n",
      "        whiskerprops : dict, optional (None)\n",
      "            Specifies the style of the whiskers.\n",
      "        flierprops : dict, optional (None)\n",
      "            Specifies the style of the fliers.\n",
      "        medianprops : dict, optional (None)\n",
      "            Specifies the style of the median.\n",
      "        meanprops : dict, optional (None)\n",
      "            Specifies the style of the mean.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        result : dict\n",
      "          A dictionary mapping each component of the boxplot to a list\n",
      "          of the :class:`matplotlib.lines.Line2D` instances\n",
      "          created. That dictionary has the following keys (assuming\n",
      "          vertical boxplots):\n",
      "        \n",
      "          - ``boxes``: the main body of the boxplot showing the\n",
      "            quartiles and the median's confidence intervals if\n",
      "            enabled.\n",
      "        \n",
      "          - ``medians``: horizontal lines at the median of each box.\n",
      "        \n",
      "          - ``whiskers``: the vertical lines extending to the most\n",
      "            extreme, non-outlier data points.\n",
      "        \n",
      "          - ``caps``: the horizontal lines at the ends of the\n",
      "            whiskers.\n",
      "        \n",
      "          - ``fliers``: points representing data that extend beyond\n",
      "            the whiskers (fliers).\n",
      "        \n",
      "          - ``means``: points or lines representing the means.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    broken_barh(xranges, yrange, hold=None, data=None, **kwargs)\n",
      "        Plot horizontal bars.\n",
      "        \n",
      "        A collection of horizontal bars spanning *yrange* with a sequence of\n",
      "        *xranges*.\n",
      "        \n",
      "        Required arguments:\n",
      "        \n",
      "          =========   ==============================\n",
      "          Argument    Description\n",
      "          =========   ==============================\n",
      "          *xranges*   sequence of (*xmin*, *xwidth*)\n",
      "          *yrange*    sequence of (*ymin*, *ywidth*)\n",
      "          =========   ==============================\n",
      "        \n",
      "        kwargs are\n",
      "        :class:`matplotlib.collections.BrokenBarHCollection`\n",
      "        properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        these can either be a single argument, i.e.,::\n",
      "        \n",
      "          facecolors = 'black'\n",
      "        \n",
      "        or a sequence of arguments for the various bars, i.e.,::\n",
      "        \n",
      "          facecolors = ('black', 'red', 'green')\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    cla()\n",
      "        Clear the current axes.\n",
      "    \n",
      "    clabel(CS, *args, **kwargs)\n",
      "        Label a contour plot.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          clabel(cs, **kwargs)\n",
      "        \n",
      "        Adds labels to line contours in *cs*, where *cs* is a\n",
      "        :class:`~matplotlib.contour.ContourSet` object returned by\n",
      "        contour.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          clabel(cs, v, **kwargs)\n",
      "        \n",
      "        only labels contours listed in *v*.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *fontsize*:\n",
      "            size in points or relative size e.g., 'smaller', 'x-large'\n",
      "        \n",
      "          *colors*:\n",
      "            - if *None*, the color of each label matches the color of\n",
      "              the corresponding contour\n",
      "        \n",
      "            - if one string color, e.g., *colors* = 'r' or *colors* =\n",
      "              'red', all labels will be plotted in this color\n",
      "        \n",
      "            - if a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "              different labels will be plotted in different colors in the order\n",
      "              specified\n",
      "        \n",
      "          *inline*:\n",
      "            controls whether the underlying contour is removed or\n",
      "            not. Default is *True*.\n",
      "        \n",
      "          *inline_spacing*:\n",
      "            space in pixels to leave on each side of label when\n",
      "            placing inline.  Defaults to 5.  This spacing will be\n",
      "            exact for labels at locations where the contour is\n",
      "            straight, less so for labels on curved contours.\n",
      "        \n",
      "          *fmt*:\n",
      "            a format string for the label. Default is '%1.3f'\n",
      "            Alternatively, this can be a dictionary matching contour\n",
      "            levels with arbitrary strings to use for each contour level\n",
      "            (i.e., fmt[level]=string), or it can be any callable, such\n",
      "            as a :class:`~matplotlib.ticker.Formatter` instance, that\n",
      "            returns a string when called with a numeric contour level.\n",
      "        \n",
      "          *manual*:\n",
      "            if *True*, contour labels will be placed manually using\n",
      "            mouse clicks.  Click the first button near a contour to\n",
      "            add a label, click the second button (or potentially both\n",
      "            mouse buttons at once) to finish adding labels.  The third\n",
      "            button can be used to remove the last label added, but\n",
      "            only if labels are not inline.  Alternatively, the keyboard\n",
      "            can be used to select label locations (enter to end label\n",
      "            placement, delete or backspace act like the third mouse button,\n",
      "            and any other key will select a label location).\n",
      "        \n",
      "            *manual* can be an iterable object of x,y tuples. Contour labels\n",
      "            will be created as if mouse is clicked at each x,y positions.\n",
      "        \n",
      "          *rightside_up*:\n",
      "            if *True* (default), label rotations will always be plus\n",
      "            or minus 90 degrees from level.\n",
      "        \n",
      "          *use_clabeltext*:\n",
      "            if *True* (default is False), ClabelText class (instead of\n",
      "            matplotlib.Text) is used to create labels. ClabelText\n",
      "            recalculates rotation angles of texts during the drawing time,\n",
      "            therefore this can be used if aspect of the axes changes.\n",
      "    \n",
      "    clf()\n",
      "        Clear the current figure.\n",
      "    \n",
      "    clim(vmin=None, vmax=None)\n",
      "        Set the color limits of the current image.\n",
      "        \n",
      "        To apply clim to all axes images do::\n",
      "        \n",
      "          clim(0, 0.5)\n",
      "        \n",
      "        If either *vmin* or *vmax* is None, the image min/max respectively\n",
      "        will be used for color scaling.\n",
      "        \n",
      "        If you want to set the clim of multiple images,\n",
      "        use, for example::\n",
      "        \n",
      "          for im in gca().get_images():\n",
      "              im.set_clim(0, 0.05)\n",
      "    \n",
      "    close(*args)\n",
      "        Close a figure window.\n",
      "        \n",
      "        ``close()`` by itself closes the current figure\n",
      "        \n",
      "        ``close(fig)`` closes the `~.Figure` instance *fig*\n",
      "        \n",
      "        ``close(num)`` closes the figure number *num*\n",
      "        \n",
      "        ``close(name)`` where *name* is a string, closes figure with that label\n",
      "        \n",
      "        ``close('all')`` closes all the figure windows\n",
      "    \n",
      "    cohere(x, y, NFFT=256, Fs=2, Fc=0, detrend=<function detrend_none at 0xac9008e8>, window=<function window_hanning at 0xac900738>, noverlap=0, pad_to=None, sides='default', scale_by_freq=None, hold=None, data=None, **kwargs)\n",
      "        Plot the coherence between *x* and *y*.\n",
      "        \n",
      "        Plot the coherence between *x* and *y*.  Coherence is the\n",
      "        normalized cross spectral density:\n",
      "        \n",
      "        .. math::\n",
      "        \n",
      "          C_{xy} = \\frac{|P_{xy}|^2}{P_{xx}P_{yy}}\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between blocks.  The\n",
      "            default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        The return value is a tuple (*Cxy*, *f*), where *f* are the\n",
      "        frequencies of the coherence vector.\n",
      "        \n",
      "        kwargs are applied to the lines.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    colorbar(mappable=None, cax=None, ax=None, **kw)\n",
      "        Add a colorbar to a plot.\n",
      "        \n",
      "        Function signatures for the :mod:`~matplotlib.pyplot` interface; all\n",
      "        but the first are also method signatures for the\n",
      "        :meth:`~matplotlib.figure.Figure.colorbar` method::\n",
      "        \n",
      "          colorbar(**kwargs)\n",
      "          colorbar(mappable, **kwargs)\n",
      "          colorbar(mappable, cax=cax, **kwargs)\n",
      "          colorbar(mappable, ax=ax, **kwargs)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        mappable :\n",
      "            The :class:`~matplotlib.image.Image`,\n",
      "            :class:`~matplotlib.contour.ContourSet`, etc. to\n",
      "            which the colorbar applies; this argument is mandatory for the Figure\n",
      "            :meth:`~matplotlib.figure.Figure.colorbar` method but optional for the\n",
      "            pyplot :func:`~matplotlib.pyplot.colorbar` function, which sets the\n",
      "            default to the current image.\n",
      "        \n",
      "        cax : :class:`~matplotlib.axes.Axes` object, optional\n",
      "            Axis into which the colorbar will be drawn\n",
      "        \n",
      "        ax : :class:`~matplotlib.axes.Axes`, list of Axes, optional\n",
      "            Parent axes from which space for a new colorbar axes will be stolen.\n",
      "            If a list of axes is given they will all be resized to make room for the\n",
      "            colorbar axes.\n",
      "        \n",
      "        use_gridspec : bool, optional\n",
      "            If *cax* is ``None``, a new *cax* is created as an instance of\n",
      "            Axes. If *ax* is an instance of Subplot and *use_gridspec* is ``True``,\n",
      "            *cax* is created as an instance of Subplot using the\n",
      "            grid_spec module.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        :class:`~matplotlib.colorbar.Colorbar` instance\n",
      "            See also its base class, :class:`~matplotlib.colorbar.ColorbarBase`.\n",
      "            Call the :meth:`~matplotlib.colorbar.ColorbarBase.set_label` method\n",
      "            to label the colorbar.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional keyword arguments are of two kinds:\n",
      "        \n",
      "          axes properties:\n",
      "        \n",
      "        \n",
      "            ============= ====================================================\n",
      "            Property      Description\n",
      "            ============= ====================================================\n",
      "            *orientation* vertical or horizontal\n",
      "            *fraction*    0.15; fraction of original axes to use for colorbar\n",
      "            *pad*         0.05 if vertical, 0.15 if horizontal; fraction\n",
      "                          of original axes between colorbar and new image axes\n",
      "            *shrink*      1.0; fraction by which to multiply the size of the colorbar\n",
      "            *aspect*      20; ratio of long to short dimensions\n",
      "            *anchor*      (0.0, 0.5) if vertical; (0.5, 1.0) if horizontal;\n",
      "                          the anchor point of the colorbar axes\n",
      "            *panchor*     (1.0, 0.5) if vertical; (0.5, 0.0) if horizontal;\n",
      "                          the anchor point of the colorbar parent axes. If\n",
      "                          False, the parent axes' anchor will be unchanged\n",
      "            ============= ====================================================\n",
      "        \n",
      "        \n",
      "          colorbar properties:\n",
      "        \n",
      "        \n",
      "            ============  ====================================================\n",
      "            Property      Description\n",
      "            ============  ====================================================\n",
      "            *extend*      [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "                          If not 'neither', make pointed end(s) for out-of-\n",
      "                          range values.  These are set for a given colormap\n",
      "                          using the colormap set_under and set_over methods.\n",
      "            *extendfrac*  [ *None* | 'auto' | length | lengths ]\n",
      "                          If set to *None*, both the minimum and maximum\n",
      "                          triangular colorbar extensions with have a length of\n",
      "                          5% of the interior colorbar length (this is the\n",
      "                          default setting). If set to 'auto', makes the\n",
      "                          triangular colorbar extensions the same lengths as\n",
      "                          the interior boxes (when *spacing* is set to\n",
      "                          'uniform') or the same lengths as the respective\n",
      "                          adjacent interior boxes (when *spacing* is set to\n",
      "                          'proportional'). If a scalar, indicates the length\n",
      "                          of both the minimum and maximum triangular colorbar\n",
      "                          extensions as a fraction of the interior colorbar\n",
      "                          length. A two-element sequence of fractions may also\n",
      "                          be given, indicating the lengths of the minimum and\n",
      "                          maximum colorbar extensions respectively as a\n",
      "                          fraction of the interior colorbar length.\n",
      "            *extendrect*  [ *False* | *True* ]\n",
      "                          If *False* the minimum and maximum colorbar extensions\n",
      "                          will be triangular (the default). If *True* the\n",
      "                          extensions will be rectangular.\n",
      "            *spacing*     [ 'uniform' | 'proportional' ]\n",
      "                          Uniform spacing gives each discrete color the same\n",
      "                          space; proportional makes the space proportional to\n",
      "                          the data interval.\n",
      "            *ticks*       [ None | list of ticks | Locator object ]\n",
      "                          If None, ticks are determined automatically from the\n",
      "                          input.\n",
      "            *format*      [ None | format string | Formatter object ]\n",
      "                          If None, the\n",
      "                          :class:`~matplotlib.ticker.ScalarFormatter` is used.\n",
      "                          If a format string is given, e.g., '%.3f', that is\n",
      "                          used. An alternative\n",
      "                          :class:`~matplotlib.ticker.Formatter` object may be\n",
      "                          given instead.\n",
      "            *drawedges*   [ False | True ] If true, draw lines at color\n",
      "                          boundaries.\n",
      "            ============  ====================================================\n",
      "        \n",
      "            The following will probably be useful only in the context of\n",
      "            indexed colors (that is, when the mappable has norm=NoNorm()),\n",
      "            or other unusual circumstances.\n",
      "        \n",
      "            ============   ===================================================\n",
      "            Property       Description\n",
      "            ============   ===================================================\n",
      "            *boundaries*   None or a sequence\n",
      "            *values*       None or a sequence which must be of length 1 less\n",
      "                           than the sequence of *boundaries*. For each region\n",
      "                           delimited by adjacent entries in *boundaries*, the\n",
      "                           color mapped to the corresponding value in values\n",
      "                           will be used.\n",
      "            ============   ===================================================\n",
      "        \n",
      "        \n",
      "        \n",
      "        If *mappable* is a :class:`~matplotlib.contours.ContourSet`, its *extend*\n",
      "        kwarg is included automatically.\n",
      "        \n",
      "        Note that the *shrink* kwarg provides a simple way to keep a vertical\n",
      "        colorbar, for example, from being taller than the axes of the mappable\n",
      "        to which the colorbar is attached; but it is a manual method requiring\n",
      "        some trial and error. If the colorbar is too tall (or a horizontal\n",
      "        colorbar is too wide) use a smaller value of *shrink*.\n",
      "        \n",
      "        For more precise control, you can manually specify the positions of\n",
      "        the axes objects in which the mappable and the colorbar are drawn.  In\n",
      "        this case, do not use any of the axes properties kwargs.\n",
      "        \n",
      "        It is known that some vector graphics viewer (svg and pdf) renders white gaps\n",
      "        between segments of the colorbar. This is due to bugs in the viewers not\n",
      "        matplotlib. As a workaround the colorbar can be rendered with overlapping\n",
      "        segments::\n",
      "        \n",
      "            cbar = colorbar()\n",
      "            cbar.solids.set_edgecolor(\"face\")\n",
      "            draw()\n",
      "        \n",
      "        However this has negative consequences in other circumstances. Particularly\n",
      "        with semi transparent images (alpha < 1) and colorbar extensions and is not\n",
      "        enabled by default see (issue #1188).\n",
      "    \n",
      "    colormaps()\n",
      "        Matplotlib provides a number of colormaps, and others can be added using\n",
      "        :func:`~matplotlib.cm.register_cmap`.  This function documents the built-in\n",
      "        colormaps, and will also return a list of all registered colormaps if called.\n",
      "        \n",
      "        You can set the colormap for an image, pcolor, scatter, etc,\n",
      "        using a keyword argument::\n",
      "        \n",
      "          imshow(X, cmap=cm.hot)\n",
      "        \n",
      "        or using the :func:`set_cmap` function::\n",
      "        \n",
      "          imshow(X)\n",
      "          pyplot.set_cmap('hot')\n",
      "          pyplot.set_cmap('jet')\n",
      "        \n",
      "        In interactive mode, :func:`set_cmap` will update the colormap post-hoc,\n",
      "        allowing you to see which one works best for your data.\n",
      "        \n",
      "        All built-in colormaps can be reversed by appending ``_r``: For instance,\n",
      "        ``gray_r`` is the reverse of ``gray``.\n",
      "        \n",
      "        There are several common color schemes used in visualization:\n",
      "        \n",
      "        Sequential schemes\n",
      "          for unipolar data that progresses from low to high\n",
      "        Diverging schemes\n",
      "          for bipolar data that emphasizes positive or negative deviations from a\n",
      "          central value\n",
      "        Cyclic schemes\n",
      "          meant for plotting values that wrap around at the\n",
      "          endpoints, such as phase angle, wind direction, or time of day\n",
      "        Qualitative schemes\n",
      "          for nominal data that has no inherent ordering, where color is used\n",
      "          only to distinguish categories\n",
      "        \n",
      "        Matplotlib ships with 4 perceptually uniform color maps which are\n",
      "        the recommended color maps for sequential data:\n",
      "        \n",
      "          =========   ===================================================\n",
      "          Colormap    Description\n",
      "          =========   ===================================================\n",
      "          inferno     perceptually uniform shades of black-red-yellow\n",
      "          magma       perceptually uniform shades of black-red-white\n",
      "          plasma      perceptually uniform shades of blue-red-yellow\n",
      "          viridis     perceptually uniform shades of blue-green-yellow\n",
      "          =========   ===================================================\n",
      "        \n",
      "        The following colormaps are based on the `ColorBrewer\n",
      "        <http://colorbrewer2.org>`_ color specifications and designs developed by\n",
      "        Cynthia Brewer:\n",
      "        \n",
      "        ColorBrewer Diverging (luminance is highest at the midpoint, and\n",
      "        decreases towards differently-colored endpoints):\n",
      "        \n",
      "          ========  ===================================\n",
      "          Colormap  Description\n",
      "          ========  ===================================\n",
      "          BrBG      brown, white, blue-green\n",
      "          PiYG      pink, white, yellow-green\n",
      "          PRGn      purple, white, green\n",
      "          PuOr      orange, white, purple\n",
      "          RdBu      red, white, blue\n",
      "          RdGy      red, white, gray\n",
      "          RdYlBu    red, yellow, blue\n",
      "          RdYlGn    red, yellow, green\n",
      "          Spectral  red, orange, yellow, green, blue\n",
      "          ========  ===================================\n",
      "        \n",
      "        ColorBrewer Sequential (luminance decreases monotonically):\n",
      "        \n",
      "          ========  ====================================\n",
      "          Colormap  Description\n",
      "          ========  ====================================\n",
      "          Blues     white to dark blue\n",
      "          BuGn      white, light blue, dark green\n",
      "          BuPu      white, light blue, dark purple\n",
      "          GnBu      white, light green, dark blue\n",
      "          Greens    white to dark green\n",
      "          Greys     white to black (not linear)\n",
      "          Oranges   white, orange, dark brown\n",
      "          OrRd      white, orange, dark red\n",
      "          PuBu      white, light purple, dark blue\n",
      "          PuBuGn    white, light purple, dark green\n",
      "          PuRd      white, light purple, dark red\n",
      "          Purples   white to dark purple\n",
      "          RdPu      white, pink, dark purple\n",
      "          Reds      white to dark red\n",
      "          YlGn      light yellow, dark green\n",
      "          YlGnBu    light yellow, light green, dark blue\n",
      "          YlOrBr    light yellow, orange, dark brown\n",
      "          YlOrRd    light yellow, orange, dark red\n",
      "          ========  ====================================\n",
      "        \n",
      "        ColorBrewer Qualitative:\n",
      "        \n",
      "        (For plotting nominal data, :class:`ListedColormap` is used,\n",
      "        not :class:`LinearSegmentedColormap`.  Different sets of colors are\n",
      "        recommended for different numbers of categories.)\n",
      "        \n",
      "        * Accent\n",
      "        * Dark2\n",
      "        * Paired\n",
      "        * Pastel1\n",
      "        * Pastel2\n",
      "        * Set1\n",
      "        * Set2\n",
      "        * Set3\n",
      "        \n",
      "        A set of colormaps derived from those of the same name provided\n",
      "        with Matlab are also included:\n",
      "        \n",
      "          =========   =======================================================\n",
      "          Colormap    Description\n",
      "          =========   =======================================================\n",
      "          autumn      sequential linearly-increasing shades of red-orange-yellow\n",
      "          bone        sequential increasing black-white color map with\n",
      "                      a tinge of blue, to emulate X-ray film\n",
      "          cool        linearly-decreasing shades of cyan-magenta\n",
      "          copper      sequential increasing shades of black-copper\n",
      "          flag        repetitive red-white-blue-black pattern (not cyclic at\n",
      "                      endpoints)\n",
      "          gray        sequential linearly-increasing black-to-white\n",
      "                      grayscale\n",
      "          hot         sequential black-red-yellow-white, to emulate blackbody\n",
      "                      radiation from an object at increasing temperatures\n",
      "          hsv         cyclic red-yellow-green-cyan-blue-magenta-red, formed\n",
      "                      by changing the hue component in the HSV color space\n",
      "          jet         a spectral map with dark endpoints, blue-cyan-yellow-red;\n",
      "                      based on a fluid-jet simulation by NCSA [#]_\n",
      "          pink        sequential increasing pastel black-pink-white, meant\n",
      "                      for sepia tone colorization of photographs\n",
      "          prism       repetitive red-yellow-green-blue-purple-...-green pattern\n",
      "                      (not cyclic at endpoints)\n",
      "          spring      linearly-increasing shades of magenta-yellow\n",
      "          summer      sequential linearly-increasing shades of green-yellow\n",
      "          winter      linearly-increasing shades of blue-green\n",
      "          =========   =======================================================\n",
      "        \n",
      "        A set of palettes from the `Yorick scientific visualisation\n",
      "        package <https://dhmunro.github.io/yorick-doc/>`_, an evolution of\n",
      "        the GIST package, both by David H. Munro are included:\n",
      "        \n",
      "          ============  =======================================================\n",
      "          Colormap      Description\n",
      "          ============  =======================================================\n",
      "          gist_earth    mapmaker's colors from dark blue deep ocean to green\n",
      "                        lowlands to brown highlands to white mountains\n",
      "          gist_heat     sequential increasing black-red-orange-white, to emulate\n",
      "                        blackbody radiation from an iron bar as it grows hotter\n",
      "          gist_ncar     pseudo-spectral black-blue-green-yellow-red-purple-white\n",
      "                        colormap from National Center for Atmospheric\n",
      "                        Research [#]_\n",
      "          gist_rainbow  runs through the colors in spectral order from red to\n",
      "                        violet at full saturation (like *hsv* but not cyclic)\n",
      "          gist_stern    \"Stern special\" color table from Interactive Data\n",
      "                        Language software\n",
      "          ============  =======================================================\n",
      "        \n",
      "        \n",
      "        Other miscellaneous schemes:\n",
      "        \n",
      "          ============= =======================================================\n",
      "          Colormap      Description\n",
      "          ============= =======================================================\n",
      "          afmhot        sequential black-orange-yellow-white blackbody\n",
      "                        spectrum, commonly used in atomic force microscopy\n",
      "          brg           blue-red-green\n",
      "          bwr           diverging blue-white-red\n",
      "          coolwarm      diverging blue-gray-red, meant to avoid issues with 3D\n",
      "                        shading, color blindness, and ordering of colors [#]_\n",
      "          CMRmap        \"Default colormaps on color images often reproduce to\n",
      "                        confusing grayscale images. The proposed colormap\n",
      "                        maintains an aesthetically pleasing color image that\n",
      "                        automatically reproduces to a monotonic grayscale with\n",
      "                        discrete, quantifiable saturation levels.\" [#]_\n",
      "          cubehelix     Unlike most other color schemes cubehelix was designed\n",
      "                        by D.A. Green to be monotonically increasing in terms\n",
      "                        of perceived brightness. Also, when printed on a black\n",
      "                        and white postscript printer, the scheme results in a\n",
      "                        greyscale with monotonically increasing brightness.\n",
      "                        This color scheme is named cubehelix because the r,g,b\n",
      "                        values produced can be visualised as a squashed helix\n",
      "                        around the diagonal in the r,g,b color cube.\n",
      "          gnuplot       gnuplot's traditional pm3d scheme\n",
      "                        (black-blue-red-yellow)\n",
      "          gnuplot2      sequential color printable as gray\n",
      "                        (black-blue-violet-yellow-white)\n",
      "          ocean         green-blue-white\n",
      "          rainbow       spectral purple-blue-green-yellow-orange-red colormap\n",
      "                        with diverging luminance\n",
      "          seismic       diverging blue-white-red\n",
      "          nipy_spectral black-purple-blue-green-yellow-red-white spectrum,\n",
      "                        originally from the Neuroimaging in Python project\n",
      "          terrain       mapmaker's colors, blue-green-yellow-brown-white,\n",
      "                        originally from IGOR Pro\n",
      "          ============= =======================================================\n",
      "        \n",
      "        The following colormaps are redundant and may be removed in future\n",
      "        versions.  It's recommended to use the names in the descriptions\n",
      "        instead, which produce identical output:\n",
      "        \n",
      "          =========  =======================================================\n",
      "          Colormap   Description\n",
      "          =========  =======================================================\n",
      "          gist_gray  identical to *gray*\n",
      "          gist_yarg  identical to *gray_r*\n",
      "          binary     identical to *gray_r*\n",
      "          spectral   identical to *nipy_spectral* [#]_\n",
      "          =========  =======================================================\n",
      "        \n",
      "        .. rubric:: Footnotes\n",
      "        \n",
      "        .. [#] Rainbow colormaps, ``jet`` in particular, are considered a poor\n",
      "          choice for scientific visualization by many researchers: `Rainbow Color\n",
      "          Map (Still) Considered Harmful\n",
      "          <http://ieeexplore.ieee.org/document/4118486/?arnumber=4118486>`_\n",
      "        \n",
      "        .. [#] Resembles \"BkBlAqGrYeOrReViWh200\" from NCAR Command\n",
      "          Language. See `Color Table Gallery\n",
      "          <https://www.ncl.ucar.edu/Document/Graphics/color_table_gallery.shtml>`_\n",
      "        \n",
      "        .. [#] See `Diverging Color Maps for Scientific Visualization\n",
      "          <http://www.kennethmoreland.com/color-maps/>`_ by Kenneth Moreland.\n",
      "        \n",
      "        .. [#] See `A Color Map for Effective Black-and-White Rendering of\n",
      "          Color-Scale Images\n",
      "          <https://www.mathworks.com/matlabcentral/fileexchange/2662-cmrmap-m>`_\n",
      "          by Carey Rappaport\n",
      "        \n",
      "        .. [#] Changed to distinguish from ColorBrewer's *Spectral* map.\n",
      "          :func:`spectral` still works, but\n",
      "          ``set_cmap('nipy_spectral')`` is recommended for clarity.\n",
      "    \n",
      "    colors()\n",
      "        .. deprecated:: 2.1\n",
      "            The colors function was deprecated in version 2.1.\n",
      "        \n",
      "        This is a do-nothing function to provide you with help on how\n",
      "        matplotlib handles colors.\n",
      "        \n",
      "        Commands which take color arguments can use several formats to\n",
      "        specify the colors.  For the basic built-in colors, you can use a\n",
      "        single letter\n",
      "        \n",
      "          =====   =======\n",
      "          Alias   Color\n",
      "          =====   =======\n",
      "          'b'     blue\n",
      "          'g'     green\n",
      "          'r'     red\n",
      "          'c'     cyan\n",
      "          'm'     magenta\n",
      "          'y'     yellow\n",
      "          'k'     black\n",
      "          'w'     white\n",
      "          =====   =======\n",
      "        \n",
      "        For a greater range of colors, you have two options.  You can\n",
      "        specify the color using an html hex string, as in::\n",
      "        \n",
      "          color = '#eeefff'\n",
      "        \n",
      "        or you can pass an R,G,B tuple, where each of R,G,B are in the\n",
      "        range [0,1].\n",
      "        \n",
      "        You can also use any legal html name for a color, for example::\n",
      "        \n",
      "          color = 'red'\n",
      "          color = 'burlywood'\n",
      "          color = 'chartreuse'\n",
      "        \n",
      "        The example below creates a subplot with a dark\n",
      "        slate gray background::\n",
      "        \n",
      "           subplot(111, facecolor=(0.1843, 0.3098, 0.3098))\n",
      "        \n",
      "        Here is an example that creates a pale turquoise title::\n",
      "        \n",
      "          title('Is this the best color?', color='#afeeee')\n",
      "    \n",
      "    connect(s, func)\n",
      "        Connect event with string *s* to *func*.  The signature of *func* is::\n",
      "        \n",
      "          def func(event)\n",
      "        \n",
      "        where event is a :class:`matplotlib.backend_bases.Event`.  The\n",
      "        following events are recognized\n",
      "        \n",
      "        - 'button_press_event'\n",
      "        - 'button_release_event'\n",
      "        - 'draw_event'\n",
      "        - 'key_press_event'\n",
      "        - 'key_release_event'\n",
      "        - 'motion_notify_event'\n",
      "        - 'pick_event'\n",
      "        - 'resize_event'\n",
      "        - 'scroll_event'\n",
      "        - 'figure_enter_event',\n",
      "        - 'figure_leave_event',\n",
      "        - 'axes_enter_event',\n",
      "        - 'axes_leave_event'\n",
      "        - 'close_event'\n",
      "        \n",
      "        For the location events (button and key press/release), if the\n",
      "        mouse is over the axes, the variable ``event.inaxes`` will be\n",
      "        set to the :class:`~matplotlib.axes.Axes` the event occurs is\n",
      "        over, and additionally, the variables ``event.xdata`` and\n",
      "        ``event.ydata`` will be defined.  This is the mouse location\n",
      "        in data coords.  See\n",
      "        :class:`~matplotlib.backend_bases.KeyEvent` and\n",
      "        :class:`~matplotlib.backend_bases.MouseEvent` for more info.\n",
      "        \n",
      "        Return value is a connection id that can be used with\n",
      "        :meth:`~matplotlib.backend_bases.Event.mpl_disconnect`.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Usage::\n",
      "        \n",
      "            def on_press(event):\n",
      "                print('you pressed', event.button, event.xdata, event.ydata)\n",
      "        \n",
      "            cid = canvas.mpl_connect('button_press_event', on_press)\n",
      "    \n",
      "    contour(*args, **kwargs)\n",
      "        Plot contours.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contour` and\n",
      "        :func:`~matplotlib.pyplot.contourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB\n",
      "        version in that it does not draw the polygon edges.\n",
      "        To draw edges, add line contours with\n",
      "        calls to :func:`~matplotlib.pyplot.contour`.\n",
      "        \n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          contour(Z)\n",
      "        \n",
      "        make a contour plot of an array *Z*. The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(X,Y,Z)\n",
      "        \n",
      "        *X*, *Y* specify the (x, y) coordinates of the surface\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,N)\n",
      "          contour(X,Y,Z,N)\n",
      "        \n",
      "        contour up to *N* automatically-chosen levels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,V)\n",
      "          contour(X,Y,Z,V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contourf(..., V)\n",
      "        \n",
      "        fill the ``len(V)-1`` regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        *X* and *Y* must both be 2-D with the same shape as *Z*, or they\n",
      "        must both be 1-D such that ``len(X)`` is the number of columns in\n",
      "        *Z* and ``len(Y)`` is the number of rows in *Z*.\n",
      "        \n",
      "        ``C = contour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.QuadContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *corner_mask*: [ *True* | *False* | 'legacy' ]\n",
      "            Enable/disable corner masking, which only has an effect if *Z* is\n",
      "            a masked array.  If *False*, any quad touching a masked point is\n",
      "            masked out.  If *True*, only the triangular corners of quads\n",
      "            nearest those points are always masked out, other triangular\n",
      "            corners comprising three unmasked points are contoured as usual.\n",
      "            If 'legacy', the old contouring algorithm is used, which is\n",
      "            equivalent to *False* and is deprecated, only remaining whilst the\n",
      "            new algorithm is tested fully.\n",
      "        \n",
      "            If not specified, the default is taken from\n",
      "            rcParams['contour.corner_mask'], which is True unless it has\n",
      "            been modified.\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *vmin*, *vmax*: [ *None* | scalar ]\n",
      "            If not *None*, either or both of these values will be\n",
      "            supplied to the :class:`matplotlib.colors.Normalize`\n",
      "            instance, overriding the default color scaling based on\n",
      "            *levels*.\n",
      "        \n",
      "          *levels*: [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is *None*, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "          *antialiased*: [ *True* | *False* ]\n",
      "            enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from rcParams['lines.antialiased'].\n",
      "        \n",
      "          *nchunk*: [ 0 | integer ]\n",
      "            If 0, no subdivision of the domain.  Specify a positive integer to\n",
      "            divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      "            Chunking reduces the maximum length of polygons generated by the\n",
      "            contouring algorithm which reduces the rendering workload passed\n",
      "            on to the backend and also requires slightly less RAM.  It can\n",
      "            however introduce rendering artifacts at chunk boundaries depending\n",
      "            on the backend, the *antialiased* flag and value of *alpha*.\n",
      "        \n",
      "        contour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified.\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the default is 'solid' unless\n",
      "            the lines are monochrome.  In that case, negative\n",
      "            contours will take their linestyle from the ``matplotlibrc``\n",
      "            ``contour.negative_linestyle`` setting.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "        contourf-only keyword arguments:\n",
      "        \n",
      "          *hatches*:\n",
      "            A list of cross hatch patterns to use on the filled areas.\n",
      "            If None, no hatching will be added to the contour.\n",
      "            Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      "            backends only.\n",
      "        \n",
      "        \n",
      "        Note: contourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    contourf(*args, **kwargs)\n",
      "        Plot contours.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contour` and\n",
      "        :func:`~matplotlib.pyplot.contourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.contourf` differs from the MATLAB\n",
      "        version in that it does not draw the polygon edges.\n",
      "        To draw edges, add line contours with\n",
      "        calls to :func:`~matplotlib.pyplot.contour`.\n",
      "        \n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          contour(Z)\n",
      "        \n",
      "        make a contour plot of an array *Z*. The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(X,Y,Z)\n",
      "        \n",
      "        *X*, *Y* specify the (x, y) coordinates of the surface\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,N)\n",
      "          contour(X,Y,Z,N)\n",
      "        \n",
      "        contour up to *N* automatically-chosen levels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z,V)\n",
      "          contour(X,Y,Z,V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contourf(..., V)\n",
      "        \n",
      "        fill the ``len(V)-1`` regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          contour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        *X* and *Y* must both be 2-D with the same shape as *Z*, or they\n",
      "        must both be 1-D such that ``len(X)`` is the number of columns in\n",
      "        *Z* and ``len(Y)`` is the number of rows in *Z*.\n",
      "        \n",
      "        ``C = contour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.QuadContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *corner_mask*: [ *True* | *False* | 'legacy' ]\n",
      "            Enable/disable corner masking, which only has an effect if *Z* is\n",
      "            a masked array.  If *False*, any quad touching a masked point is\n",
      "            masked out.  If *True*, only the triangular corners of quads\n",
      "            nearest those points are always masked out, other triangular\n",
      "            corners comprising three unmasked points are contoured as usual.\n",
      "            If 'legacy', the old contouring algorithm is used, which is\n",
      "            equivalent to *False* and is deprecated, only remaining whilst the\n",
      "            new algorithm is tested fully.\n",
      "        \n",
      "            If not specified, the default is taken from\n",
      "            rcParams['contour.corner_mask'], which is True unless it has\n",
      "            been modified.\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *vmin*, *vmax*: [ *None* | scalar ]\n",
      "            If not *None*, either or both of these values will be\n",
      "            supplied to the :class:`matplotlib.colors.Normalize`\n",
      "            instance, overriding the default color scaling based on\n",
      "            *levels*.\n",
      "        \n",
      "          *levels*: [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is *None*, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "          *antialiased*: [ *True* | *False* ]\n",
      "            enable antialiasing, overriding the defaults.  For\n",
      "            filled contours, the default is *True*.  For line contours,\n",
      "            it is taken from rcParams['lines.antialiased'].\n",
      "        \n",
      "          *nchunk*: [ 0 | integer ]\n",
      "            If 0, no subdivision of the domain.  Specify a positive integer to\n",
      "            divide the domain into subdomains of *nchunk* by *nchunk* quads.\n",
      "            Chunking reduces the maximum length of polygons generated by the\n",
      "            contouring algorithm which reduces the rendering workload passed\n",
      "            on to the backend and also requires slightly less RAM.  It can\n",
      "            however introduce rendering artifacts at chunk boundaries depending\n",
      "            on the backend, the *antialiased* flag and value of *alpha*.\n",
      "        \n",
      "        contour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified.\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the default is 'solid' unless\n",
      "            the lines are monochrome.  In that case, negative\n",
      "            contours will take their linestyle from the ``matplotlibrc``\n",
      "            ``contour.negative_linestyle`` setting.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "        contourf-only keyword arguments:\n",
      "        \n",
      "          *hatches*:\n",
      "            A list of cross hatch patterns to use on the filled areas.\n",
      "            If None, no hatching will be added to the contour.\n",
      "            Hatching is supported in the PostScript, PDF, SVG and Agg\n",
      "            backends only.\n",
      "        \n",
      "        \n",
      "        Note: contourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    cool()\n",
      "        set the default colormap to cool and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    copper()\n",
      "        set the default colormap to copper and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    csd(x, y, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, hold=None, data=None, **kwargs)\n",
      "        Plot the cross-spectral density.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          csd(x, y, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "              window=mlab.window_hanning, noverlap=0, pad_to=None,\n",
      "              sides='default', scale_by_freq=None, return_line=None, **kwargs)\n",
      "        \n",
      "        The cross spectral density :math:`P_{xy}` by Welch's average\n",
      "        periodogram method.  The vectors *x* and *y* are divided into\n",
      "        *NFFT* length segments.  Each segment is detrended by function\n",
      "        *detrend* and windowed by function *window*.  *noverlap* gives\n",
      "        the length of the overlap between segments.  The product of\n",
      "        the direct FFTs of *x* and *y* are averaged over each segment\n",
      "        to compute :math:`P_{xy}`, with a scaling to correct for power\n",
      "        loss due to windowing.\n",
      "        \n",
      "        If len(*x*) < *NFFT* or len(*y*) < *NFFT*, they will be zero\n",
      "        padded to *NFFT*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : 1-D arrays or sequences\n",
      "            Arrays or sequences containing the data\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between segments.\n",
      "            The default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        return_line : bool\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "            Default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxy : 1-D array\n",
      "            The values for the cross spectrum `P_{xy}` before scaling\n",
      "            (complex valued)\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *Pxy*\n",
      "        \n",
      "        line : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function.\n",
      "            Only returned if *return_line* is True.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For plotting, the power is plotted as\n",
      "        :math:`10\\log_{10}(P_{xy})` for decibels, though `P_{xy}` itself\n",
      "        is returned.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` is the equivalent to setting y=x.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    delaxes(*args)\n",
      "        Remove an axes from the current figure.  If *ax*\n",
      "        doesn't exist, an error will be raised.\n",
      "        \n",
      "        ``delaxes()``: delete the current axes\n",
      "    \n",
      "    disconnect(cid)\n",
      "        Disconnect callback id cid\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Usage::\n",
      "        \n",
      "            cid = canvas.mpl_connect('button_press_event', on_press)\n",
      "            #...later\n",
      "            canvas.mpl_disconnect(cid)\n",
      "    \n",
      "    draw()\n",
      "        Redraw the current figure.\n",
      "        \n",
      "        This is used to update a figure that has been altered, but not\n",
      "        automatically re-drawn.  If interactive mode is on (:func:`.ion()`), this\n",
      "        should be only rarely needed, but there may be ways to modify the state of\n",
      "        a figure without marking it as `stale`.  Please report these cases as\n",
      "        bugs.\n",
      "        \n",
      "        A more object-oriented alternative, given any\n",
      "        :class:`~matplotlib.figure.Figure` instance, :attr:`fig`, that\n",
      "        was created using a :mod:`~matplotlib.pyplot` function, is::\n",
      "        \n",
      "            fig.canvas.draw_idle()\n",
      "    \n",
      "    errorbar(x, y, yerr=None, xerr=None, fmt='', ecolor=None, elinewidth=None, capsize=None, barsabove=False, lolims=False, uplims=False, xlolims=False, xuplims=False, errorevery=1, capthick=None, hold=None, data=None, **kwargs)\n",
      "        Plot an errorbar graph.\n",
      "        \n",
      "        Plot x versus y with error deltas in yerr and xerr.\n",
      "        Vertical errorbars are plotted if yerr is not None.\n",
      "        Horizontal errorbars are plotted if xerr is not None.\n",
      "        \n",
      "        x, y, xerr, and yerr can all be scalars, which plots a\n",
      "        single error bar at x, y.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : scalar or array-like\n",
      "        y : scalar or array-like\n",
      "        \n",
      "        xerr/yerr : scalar or array-like, shape(N,) or shape(2,N), optional\n",
      "            If a scalar number, len(N) array-like object, or a N-element\n",
      "            array-like object, errorbars are drawn at +/-value relative\n",
      "            to the data. Default is None.\n",
      "        \n",
      "            If a sequence of shape 2xN, errorbars are drawn at -row1\n",
      "            and +row2 relative to the data.\n",
      "        \n",
      "        fmt : plot format string, optional, default: None\n",
      "            The plot format symbol. If fmt is 'none' (case-insensitive),\n",
      "            only the errorbars are plotted.  This is used for adding\n",
      "            errorbars to a bar plot, for example.  Default is '',\n",
      "            an empty plot format string; properties are\n",
      "            then identical to the defaults for :meth:`plot`.\n",
      "        \n",
      "        ecolor : mpl color, optional, default: None\n",
      "            A matplotlib color arg which gives the color the errorbar lines;\n",
      "            if None, use the color of the line connecting the markers.\n",
      "        \n",
      "        elinewidth : scalar, optional, default: None\n",
      "            The linewidth of the errorbar lines. If None, use the linewidth.\n",
      "        \n",
      "        capsize : scalar, optional, default: None\n",
      "            The length of the error bar caps in points; if None, it will\n",
      "            take the value from ``errorbar.capsize``\n",
      "            :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        capthick : scalar, optional, default: None\n",
      "            An alias kwarg to markeredgewidth (a.k.a. - mew). This\n",
      "            setting is a more sensible name for the property that\n",
      "            controls the thickness of the error bar cap in points. For\n",
      "            backwards compatibility, if mew or markeredgewidth are given,\n",
      "            then they will over-ride capthick. This may change in future\n",
      "            releases.\n",
      "        \n",
      "        barsabove : bool, optional, default: False\n",
      "            if True , will plot the errorbars above the plot\n",
      "            symbols. Default is below.\n",
      "        \n",
      "        lolims / uplims / xlolims / xuplims : bool, optional, default:None\n",
      "            These arguments can be used to indicate that a value gives\n",
      "            only upper/lower limits. In that case a caret symbol is\n",
      "            used to indicate this. lims-arguments may be of the same\n",
      "            type as *xerr* and *yerr*.  To use limits with inverted\n",
      "            axes, :meth:`set_xlim` or :meth:`set_ylim` must be called\n",
      "            before :meth:`errorbar`.\n",
      "        \n",
      "        errorevery : positive integer, optional, default:1\n",
      "            subsamples the errorbars. e.g., if errorevery=5, errorbars for\n",
      "            every 5-th datapoint will be plotted. The data plot itself still\n",
      "            shows all data points.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        plotline : :class:`~matplotlib.lines.Line2D` instance\n",
      "            x, y plot markers and/or line\n",
      "        caplines : list of :class:`~matplotlib.lines.Line2D` instances\n",
      "            error bar cap\n",
      "        barlinecols : list of :class:`~matplotlib.collections.LineCollection`\n",
      "            horizontal and vertical error ranges.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            All other keyword arguments are passed on to the plot\n",
      "            command for the markers. For example, this code makes big red\n",
      "            squares with thick green edges::\n",
      "        \n",
      "                x,y,yerr = rand(3,10)\n",
      "                errorbar(x, y, yerr, marker='s', mfc='red',\n",
      "                         mec='green', ms=20, mew=4)\n",
      "        \n",
      "            where mfc, mec, ms and mew are aliases for the longer\n",
      "            property names, markerfacecolor, markeredgecolor, markersize\n",
      "            and markeredgewidth.\n",
      "        \n",
      "            Valid kwargs for the marker properties are\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'xerr', 'y', 'yerr'.\n",
      "    \n",
      "    eventplot(positions, orientation='horizontal', lineoffsets=1, linelengths=1, linewidths=None, colors=None, linestyles='solid', hold=None, data=None, **kwargs)\n",
      "        Plot identical parallel lines at the given positions.\n",
      "        \n",
      "        *positions* should be a 1D or 2D array-like object, with each row\n",
      "        corresponding to a row or column of lines.\n",
      "        \n",
      "        This type of plot is commonly used in neuroscience for representing\n",
      "        neural events, where it is usually called a spike raster, dot raster,\n",
      "        or raster plot.\n",
      "        \n",
      "        However, it is useful in any situation where you wish to show the\n",
      "        timing or position of multiple sets of discrete events, such as the\n",
      "        arrival times of people to a business on each day of the month or the\n",
      "        date of hurricanes each year of the last century.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        positions : 1D or 2D array-like object\n",
      "            Each value is an event. If *positions* is a 2D array-like, each\n",
      "            row corresponds to a row or a column of lines (depending on the\n",
      "            *orientation* parameter).\n",
      "        \n",
      "        orientation : {'horizontal', 'vertical'}, optional\n",
      "            Controls the direction of the event collections:\n",
      "        \n",
      "                - 'horizontal' : the lines are arranged horizontally in rows,\n",
      "                  and are vertical.\n",
      "                - 'vertical' : the lines are arranged vertically in columns,\n",
      "                  and are horizontal.\n",
      "        \n",
      "        lineoffsets : scalar or sequence of scalars, optional, default: 1\n",
      "            The offset of the center of the lines from the origin, in the\n",
      "            direction orthogonal to *orientation*.\n",
      "        \n",
      "        linelengths : scalar or sequence of scalars, optional, default: 1\n",
      "            The total height of the lines (i.e. the lines stretches from\n",
      "            ``lineoffset - linelength/2`` to ``lineoffset + linelength/2``).\n",
      "        \n",
      "        linewidths : scalar, scalar sequence or None, optional, default: None\n",
      "            The line width(s) of the event lines, in points. If it is None,\n",
      "            defaults to its rcParams setting.\n",
      "        \n",
      "        colors : color, sequence of colors or None, optional, default: None\n",
      "            The color(s) of the event lines. If it is None, defaults to its\n",
      "            rcParams setting.\n",
      "        \n",
      "        linestyles : str or tuple or a sequence of such values, optional\n",
      "            Default is 'solid'. Valid strings are ['solid', 'dashed',\n",
      "            'dashdot', 'dotted', '-', '--', '-.', ':']. Dash tuples\n",
      "            should be of the form::\n",
      "        \n",
      "                (offset, onoffseq),\n",
      "        \n",
      "            where *onoffseq* is an even length tuple of on and off ink\n",
      "            in points.\n",
      "        \n",
      "        **kwargs : optional\n",
      "            Other keyword arguments are line collection properties.  See\n",
      "            :class:`~matplotlib.collections.LineCollection` for a list of\n",
      "            the valid properties.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        \n",
      "        A list of :class:`matplotlib.collections.EventCollection` objects that\n",
      "        were added.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        For *linelengths*, *linewidths*, *colors*, and *linestyles*, if only\n",
      "        a single value is given, that value is applied to all lines.  If an\n",
      "        array-like is given, it must have the same length as *positions*, and\n",
      "        each value will be applied to the corresponding row of the array.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        .. plot:: mpl_examples/lines_bars_and_markers/eventplot_demo.py\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'linelengths', 'lineoffsets', 'linestyles', 'linewidths', 'positions'.\n",
      "    \n",
      "    figimage(*args, **kwargs)\n",
      "        Adds a non-resampled image to the figure.\n",
      "        \n",
      "        call signatures::\n",
      "        \n",
      "          figimage(X, **kwargs)\n",
      "        \n",
      "        adds a non-resampled array *X* to the figure.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          figimage(X, xo, yo)\n",
      "        \n",
      "        with pixel offsets *xo*, *yo*,\n",
      "        \n",
      "        *X* must be a float array:\n",
      "        \n",
      "        * If *X* is MxN, assume luminance (grayscale)\n",
      "        * If *X* is MxNx3, assume RGB\n",
      "        * If *X* is MxNx4, assume RGBA\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          =========   =========================================================\n",
      "          Keyword     Description\n",
      "          =========   =========================================================\n",
      "          resize      a boolean, True or False. If \"True\", then re-size the\n",
      "                      Figure to match the given image size.\n",
      "          xo or yo    An integer, the *x* and *y* image offset in pixels\n",
      "          cmap        a :class:`matplotlib.colors.Colormap` instance, e.g.,\n",
      "                      cm.jet. If *None*, default to the rc ``image.cmap``\n",
      "                      value\n",
      "          norm        a :class:`matplotlib.colors.Normalize` instance. The\n",
      "                      default is normalization().  This scales luminance -> 0-1\n",
      "          vmin|vmax   are used to scale a luminance image to 0-1.  If either\n",
      "                      is *None*, the min and max of the luminance values will\n",
      "                      be used.  Note if you pass a norm instance, the settings\n",
      "                      for *vmin* and *vmax* will be ignored.\n",
      "          alpha       the alpha blending value, default is *None*\n",
      "          origin      [ 'upper' | 'lower' ] Indicates where the [0,0] index of\n",
      "                      the array is in the upper left or lower left corner of\n",
      "                      the axes. Defaults to the rc image.origin value\n",
      "          =========   =========================================================\n",
      "        \n",
      "        figimage complements the axes image\n",
      "        (:meth:`~matplotlib.axes.Axes.imshow`) which will be resampled\n",
      "        to fit the current axes.  If you want a resampled image to\n",
      "        fill the entire figure, you can define an\n",
      "        :class:`~matplotlib.axes.Axes` with extent [0,0,1,1].\n",
      "        \n",
      "        An :class:`matplotlib.image.FigureImage` instance is returned.\n",
      "        \n",
      "        Additional kwargs are Artist kwargs passed on to\n",
      "        :class:`~matplotlib.image.FigureImage`\n",
      "    \n",
      "    figlegend(*args, **kwargs)\n",
      "        Place a legend in the figure.\n",
      "        \n",
      "        *labels*\n",
      "          a sequence of strings\n",
      "        \n",
      "        *handles*\n",
      "          a sequence of :class:`~matplotlib.lines.Line2D` or\n",
      "          :class:`~matplotlib.patches.Patch` instances\n",
      "        \n",
      "        *loc*\n",
      "          can be a string or an integer specifying the legend\n",
      "          location\n",
      "        \n",
      "        A :class:`matplotlib.legend.Legend` instance is returned.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        To make a legend from existing artists on every axes::\n",
      "        \n",
      "          figlegend()\n",
      "        \n",
      "        To make a legend for a list of lines and labels::\n",
      "        \n",
      "          figlegend( (line1, line2, line3),\n",
      "                     ('label1', 'label2', 'label3'),\n",
      "                     'upper right' )\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "           :func:`~matplotlib.pyplot.legend`\n",
      "    \n",
      "    fignum_exists(num)\n",
      "    \n",
      "    figtext(*args, **kwargs)\n",
      "        Add text to figure.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          text(x, y, s, fontdict=None, **kwargs)\n",
      "        \n",
      "        Add text to figure at location *x*, *y* (relative 0-1\n",
      "        coords). See :func:`~matplotlib.pyplot.text` for the meaning\n",
      "        of the other arguments.\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.text.Text` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          backgroundcolor: any matplotlib color \n",
      "          bbox: FancyBboxPatch prop dict \n",
      "          clip_box: a :class:`matplotlib.transforms.Bbox` instance \n",
      "          clip_on: [True | False] \n",
      "          clip_path: [ (:class:`~matplotlib.path.Path`, :class:`~matplotlib.transforms.Transform`) | :class:`~matplotlib.patches.Patch` | None ] \n",
      "          color: any matplotlib color \n",
      "          contains: a callable function \n",
      "          family or fontfamily or fontname or name: [FONTNAME | 'serif' | 'sans-serif' | 'cursive' | 'fantasy' | 'monospace' ] \n",
      "          figure: a `~.Figure` instance \n",
      "          fontproperties or font_properties: a :class:`matplotlib.font_manager.FontProperties` instance \n",
      "          gid: an id string \n",
      "          horizontalalignment or ha: [ 'center' | 'right' | 'left' ] \n",
      "          label: object \n",
      "          linespacing: float (multiple of font size) \n",
      "          multialignment or ma: ['left' | 'right' | 'center' ] \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          position: (x,y) \n",
      "          rasterized: bool or None \n",
      "          rotation: [ angle in degrees | 'vertical' | 'horizontal' ] \n",
      "          rotation_mode: [ None | \"default\" | \"anchor\" ]\n",
      "          size or fontsize: [size in points | 'xx-small' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'xx-large' ] \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          stretch or fontstretch: [a numeric value in range 0-1000 | 'ultra-condensed' | 'extra-condensed' | 'condensed' | 'semi-condensed' | 'normal' | 'semi-expanded' | 'expanded' | 'extra-expanded' | 'ultra-expanded' ] \n",
      "          style or fontstyle: [ 'normal' | 'italic' | 'oblique'] \n",
      "          text: string or anything printable with '%s' conversion. \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          usetex: bool or None \n",
      "          variant or fontvariant: [ 'normal' | 'small-caps' ] \n",
      "          verticalalignment or va: [ 'center' | 'top' | 'bottom' | 'baseline' ] \n",
      "          visible: bool \n",
      "          weight or fontweight: [a numeric value in range 0-1000 | 'ultralight' | 'light' | 'normal' | 'regular' | 'book' | 'medium' | 'roman' | 'semibold' | 'demibold' | 'demi' | 'bold' | 'heavy' | 'extra bold' | 'black' ] \n",
      "          wrap: bool\n",
      "          x: float \n",
      "          y: float \n",
      "          zorder: float\n",
      "    \n",
      "    figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None, frameon=True, FigureClass=<class 'matplotlib.figure.Figure'>, clear=False, **kwargs)\n",
      "        Creates a new figure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        num : integer or string, optional, default: none\n",
      "            If not provided, a new figure will be created, and the figure number\n",
      "            will be incremented. The figure objects holds this number in a `number`\n",
      "            attribute.\n",
      "            If num is provided, and a figure with this id already exists, make\n",
      "            it active, and returns a reference to it. If this figure does not\n",
      "            exists, create it and returns it.\n",
      "            If num is a string, the window title will be set to this figure's\n",
      "            `num`.\n",
      "        \n",
      "        figsize : tuple of integers, optional, default: None\n",
      "            width, height in inches. If not provided, defaults to rc\n",
      "            figure.figsize.\n",
      "        \n",
      "        dpi : integer, optional, default: None\n",
      "            resolution of the figure. If not provided, defaults to rc figure.dpi.\n",
      "        \n",
      "        facecolor :\n",
      "            the background color. If not provided, defaults to rc figure.facecolor.\n",
      "        \n",
      "        edgecolor :\n",
      "            the border color. If not provided, defaults to rc figure.edgecolor.\n",
      "        \n",
      "        frameon : bool, optional, default: True\n",
      "            If False, suppress drawing the figure frame.\n",
      "        \n",
      "        FigureClass : class derived from matplotlib.figure.Figure\n",
      "            Optionally use a custom Figure instance.\n",
      "        \n",
      "        clear : bool, optional, default: False\n",
      "            If True and the figure already exists, then it is cleared.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        figure : Figure\n",
      "            The Figure instance returned will also be passed to new_figure_manager\n",
      "            in the backends, which allows to hook custom Figure classes into the\n",
      "            pylab interface. Additional kwargs will be passed to the figure init\n",
      "            function.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        If you are creating many figures, make sure you explicitly call \"close\"\n",
      "        on the figures you are not using, because this will enable pylab\n",
      "        to properly clean up the memory.\n",
      "        \n",
      "        rcParams defines the default values, which can be modified in the\n",
      "        matplotlibrc file\n",
      "    \n",
      "    fill(*args, **kwargs)\n",
      "        Plot filled polygons.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        args : a variable length argument\n",
      "            It allowing for multiple\n",
      "            *x*, *y* pairs with an optional color format string; see\n",
      "            :func:`~matplotlib.pyplot.plot` for details on the argument\n",
      "            parsing.  For example, each of the following is legal::\n",
      "        \n",
      "                ax.fill(x, y)\n",
      "                ax.fill(x, y, \"b\")\n",
      "                ax.fill(x, y, \"b\", x, y, \"r\")\n",
      "        \n",
      "            An arbitrary number of *x*, *y*, *color* groups can be specified::\n",
      "            ax.fill(x1, y1, 'g', x2, y2, 'r')\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        a list of :class:`~matplotlib.patches.Patch`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : :class:`~matplotlib.patches.Polygon` properties\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The same color strings that :func:`~matplotlib.pyplot.plot`\n",
      "        supports are supported by the fill format string.\n",
      "        \n",
      "        If you would like to fill below a curve, e.g., shade a region\n",
      "        between 0 and *y* along *x*, use :meth:`fill_between`\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    fill_between(x, y1, y2=0, where=None, interpolate=False, step=None, hold=None, data=None, **kwargs)\n",
      "        Make filled polygons between two curves.\n",
      "        \n",
      "        \n",
      "        Create a :class:`~matplotlib.collections.PolyCollection`\n",
      "        filling the regions between *y1* and *y2* where\n",
      "        ``where==True``\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array\n",
      "            An N-length array of the x data\n",
      "        \n",
      "        y1 : array\n",
      "            An N-length array (or scalar) of the y data\n",
      "        \n",
      "        y2 : array\n",
      "            An N-length array (or scalar) of the y data\n",
      "        \n",
      "        where : array, optional\n",
      "            If `None`, default to fill between everywhere.  If not `None`,\n",
      "            it is an N-length numpy boolean array and the fill will\n",
      "            only happen over the regions where ``where==True``.\n",
      "        \n",
      "        interpolate : bool, optional\n",
      "            If `True`, interpolate between the two lines to find the\n",
      "            precise point of intersection.  Otherwise, the start and\n",
      "            end points of the filled region will only occur on explicit\n",
      "            values in the *x* array.\n",
      "        \n",
      "        step : {'pre', 'post', 'mid'}, optional\n",
      "            If not None, fill with step logic.\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        Additional Keyword args passed on to the\n",
      "        :class:`~matplotlib.collections.PolyCollection`.\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.patches.Polygon` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        \n",
      "            :meth:`fill_betweenx`\n",
      "                for filling between two sets of x-values\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'where', 'x', 'y1', 'y2'.\n",
      "    \n",
      "    fill_betweenx(y, x1, x2=0, where=None, step=None, interpolate=False, hold=None, data=None, **kwargs)\n",
      "        Make filled polygons between two horizontal curves.\n",
      "        \n",
      "        \n",
      "        Create a :class:`~matplotlib.collections.PolyCollection`\n",
      "        filling the regions between *x1* and *x2* where\n",
      "        ``where==True``\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : array\n",
      "            An N-length array of the y data\n",
      "        \n",
      "        x1 : array\n",
      "            An N-length array (or scalar) of the x data\n",
      "        \n",
      "        x2 : array, optional\n",
      "            An N-length array (or scalar) of the x data\n",
      "        \n",
      "        where : array, optional\n",
      "            If *None*, default to fill between everywhere.  If not *None*,\n",
      "            it is a N length numpy boolean array and the fill will\n",
      "            only happen over the regions where ``where==True``\n",
      "        \n",
      "        step : {'pre', 'post', 'mid'}, optional\n",
      "            If not None, fill with step logic.\n",
      "        \n",
      "        interpolate : bool, optional\n",
      "            If `True`, interpolate between the two lines to find the\n",
      "            precise point of intersection.  Otherwise, the start and\n",
      "            end points of the filled region will only occur on explicit\n",
      "            values in the *x* array.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        keyword args passed on to the\n",
      "            :class:`~matplotlib.collections.PolyCollection`\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.patches.Polygon` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        \n",
      "            :meth:`fill_between`\n",
      "                for filling between two sets of y-values\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'where', 'x1', 'x2', 'y'.\n",
      "    \n",
      "    findobj(o=None, match=None, include_self=True)\n",
      "        Find artist objects.\n",
      "        \n",
      "        Recursively find all :class:`~matplotlib.artist.Artist` instances\n",
      "        contained in self.\n",
      "        \n",
      "        *match* can be\n",
      "        \n",
      "          - None: return all objects contained in artist.\n",
      "        \n",
      "          - function with signature ``boolean = match(artist)``\n",
      "            used to filter matches\n",
      "        \n",
      "          - class instance: e.g., Line2D.  Only return artists of class type.\n",
      "        \n",
      "        If *include_self* is True (default), include self in the list to be\n",
      "        checked for a match.\n",
      "    \n",
      "    flag()\n",
      "        set the default colormap to flag and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    gca(**kwargs)\n",
      "        Get the current :class:`~matplotlib.axes.Axes` instance on the\n",
      "        current figure matching the given keyword args, or create one.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        To get the current polar axes on the current figure::\n",
      "        \n",
      "            plt.gca(projection='polar')\n",
      "        \n",
      "        If the current axes doesn't exist, or isn't a polar one, the appropriate\n",
      "        axes will be created and then returned.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.figure.Figure.gca : The figure's gca method.\n",
      "    \n",
      "    gcf()\n",
      "        Get a reference to the current figure.\n",
      "    \n",
      "    gci()\n",
      "        Get the current colorable artist.  Specifically, returns the\n",
      "        current :class:`~matplotlib.cm.ScalarMappable` instance (image or\n",
      "        patch collection), or *None* if no images or patch collections\n",
      "        have been defined.  The commands :func:`~matplotlib.pyplot.imshow`\n",
      "        and :func:`~matplotlib.pyplot.figimage` create\n",
      "        :class:`~matplotlib.image.Image` instances, and the commands\n",
      "        :func:`~matplotlib.pyplot.pcolor` and\n",
      "        :func:`~matplotlib.pyplot.scatter` create\n",
      "        :class:`~matplotlib.collections.Collection` instances.  The\n",
      "        current image is an attribute of the current axes, or the nearest\n",
      "        earlier axes in the current figure that contains an image.\n",
      "    \n",
      "    get_current_fig_manager()\n",
      "    \n",
      "    get_figlabels()\n",
      "        Return a list of existing figure labels.\n",
      "    \n",
      "    get_fignums()\n",
      "        Return a list of existing figure numbers.\n",
      "    \n",
      "    get_plot_commands()\n",
      "        Get a sorted list of all of the plotting commands.\n",
      "    \n",
      "    ginput(*args, **kwargs)\n",
      "        Blocking call to interact with a figure.\n",
      "        \n",
      "        Wait until the user clicks *n* times on the figure, and return the\n",
      "        coordinates of each click in a list.\n",
      "        \n",
      "        The buttons used for the various actions (adding points, removing\n",
      "        points, terminating the inputs) can be overridden via the\n",
      "        arguments *mouse_add*, *mouse_pop* and *mouse_stop*, that give\n",
      "        the associated mouse button: 1 for left, 2 for middle, 3 for\n",
      "        right.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        n : int, optional, default: 1\n",
      "            Number of mouse clicks to accumulate. If negative, accumulate\n",
      "            clicks until the input is terminated manually.\n",
      "        timeout : scalar, optional, default: 30\n",
      "            Number of seconds to wait before timing out. If zero or negative\n",
      "            will never timeout.\n",
      "        show_clicks : bool, optional, default: False\n",
      "            If True, show a red cross at the location of each click.\n",
      "        mouse_add : int, one of (1, 2, 3), optional, default: 1 (left click)\n",
      "            Mouse button used to add points.\n",
      "        mouse_pop : int, one of (1, 2, 3), optional, default: 3 (right click)\n",
      "            Mouse button used to remove the most recently added point.\n",
      "        mouse_stop : int, one of (1, 2, 3), optional, default: 2 (middle click)\n",
      "            Mouse button used to stop input.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        points : list of tuples\n",
      "            A list of the clicked (x, y) coordinates.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The keyboard can also be used to select points in case your mouse\n",
      "        does not have one or more of the buttons.  The delete and backspace\n",
      "        keys act like right clicking (i.e., remove last point), the enter key\n",
      "        terminates input and any other key (not already used by the window\n",
      "        manager) selects a point.\n",
      "    \n",
      "    gray()\n",
      "        set the default colormap to gray and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    grid(b=None, which='major', axis='both', **kwargs)\n",
      "        Turn the axes grids on or off.\n",
      "        \n",
      "        Set the axes grids on or off; *b* is a boolean.  (For MATLAB\n",
      "        compatibility, *b* may also be a string, 'on' or 'off'.)\n",
      "        \n",
      "        If *b* is *None* and ``len(kwargs)==0``, toggle the grid state.  If\n",
      "        *kwargs* are supplied, it is assumed that you want a grid and *b*\n",
      "        is thus set to *True*.\n",
      "        \n",
      "        *which* can be 'major' (default), 'minor', or 'both' to control\n",
      "        whether major tick grids, minor tick grids, or both are affected.\n",
      "        \n",
      "        *axis* can be 'both' (default), 'x', or 'y' to control which\n",
      "        set of gridlines are drawn.\n",
      "        \n",
      "        *kwargs* are used to set the grid line properties, e.g.,::\n",
      "        \n",
      "           ax.grid(color='r', linestyle='-', linewidth=2)\n",
      "        \n",
      "        Valid :class:`~matplotlib.lines.Line2D` kwargs are\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float\n",
      "    \n",
      "    hexbin(x, y, C=None, gridsize=100, bins=None, xscale='linear', yscale='linear', extent=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, edgecolors='face', reduce_C_function=<function mean at 0xb0b64bb8>, mincnt=None, marginals=False, hold=None, data=None, **kwargs)\n",
      "        Make a hexagonal binning plot.\n",
      "        \n",
      "        Make a hexagonal binning plot of *x* versus *y*, where *x*,\n",
      "        *y* are 1-D sequences of the same length, *N*. If *C* is *None*\n",
      "        (the default), this is a histogram of the number of occurrences\n",
      "        of the observations at (x[i],y[i]).\n",
      "        \n",
      "        If *C* is specified, it specifies values at the coordinate\n",
      "        (x[i],y[i]). These values are accumulated for each hexagonal\n",
      "        bin and then reduced according to *reduce_C_function*, which\n",
      "        defaults to numpy's mean function (np.mean). (If *C* is\n",
      "        specified, it must also be a 1-D sequence of the same length\n",
      "        as *x* and *y*.)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array or masked array\n",
      "        \n",
      "        C : array or masked array, optional, default is *None*\n",
      "        \n",
      "        gridsize : int or (int, int), optional, default is 100\n",
      "            The number of hexagons in the *x*-direction, default is\n",
      "            100. The corresponding number of hexagons in the\n",
      "            *y*-direction is chosen such that the hexagons are\n",
      "            approximately regular. Alternatively, gridsize can be a\n",
      "            tuple with two elements specifying the number of hexagons\n",
      "            in the *x*-direction and the *y*-direction.\n",
      "        \n",
      "        bins : {'log'} or int or sequence, optional, default is *None*\n",
      "            If *None*, no binning is applied; the color of each hexagon\n",
      "            directly corresponds to its count value.\n",
      "        \n",
      "            If 'log', use a logarithmic scale for the color\n",
      "            map. Internally, :math:`log_{10}(i+1)` is used to\n",
      "            determine the hexagon color.\n",
      "        \n",
      "            If an integer, divide the counts in the specified number\n",
      "            of bins, and color the hexagons accordingly.\n",
      "        \n",
      "            If a sequence of values, the values of the lower bound of\n",
      "            the bins to be used.\n",
      "        \n",
      "        xscale : {'linear', 'log'}, optional, default is 'linear'\n",
      "            Use a linear or log10 scale on the horizontal axis.\n",
      "        \n",
      "        yscale : {'linear', 'log'}, optional, default is 'linear'\n",
      "            Use a linear or log10 scale on the vertical axis.\n",
      "        \n",
      "        mincnt : int > 0, optional, default is *None*\n",
      "            If not *None*, only display cells with more than *mincnt*\n",
      "            number of points in the cell\n",
      "        \n",
      "        marginals : bool, optional, default is *False*\n",
      "            if marginals is *True*, plot the marginal density as\n",
      "            colormapped rectagles along the bottom of the x-axis and\n",
      "            left of the y-axis\n",
      "        \n",
      "        extent : scalar, optional, default is *None*\n",
      "            The limits of the bins. The default assigns the limits\n",
      "            based on *gridsize*, *x*, *y*, *xscale* and *yscale*.\n",
      "        \n",
      "            If *xscale* or *yscale* is set to 'log', the limits are\n",
      "            expected to be the exponent for a power of 10. E.g. for\n",
      "            x-limits of 1 and 50 in 'linear' scale and y-limits\n",
      "            of 10 and 1000 in 'log' scale, enter (1, 50, 1, 3).\n",
      "        \n",
      "            Order of scalars is (left, right, bottom, top).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : object, optional, default is *None*\n",
      "            a :class:`matplotlib.colors.Colormap` instance. If *None*,\n",
      "            defaults to rc ``image.cmap``.\n",
      "        \n",
      "        norm : object, optional, default is *None*\n",
      "            :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to 0,1.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default is *None*\n",
      "            *vmin* and *vmax* are used in conjunction with *norm* to\n",
      "            normalize luminance data. If *None*, the min and max of the\n",
      "            color array *C* are used.  Note if you pass a norm instance\n",
      "            your settings for *vmin* and *vmax* will be ignored.\n",
      "        \n",
      "        alpha : scalar between 0 and 1, optional, default is *None*\n",
      "            the alpha value for the patches\n",
      "        \n",
      "        linewidths : scalar, optional, default is *None*\n",
      "            If *None*, defaults to 1.0.\n",
      "        \n",
      "        edgecolors : {'face', 'none', *None*} or mpl color, optional, default            is 'face'\n",
      "        \n",
      "            If 'face', draws the edges in the same color as the fill color.\n",
      "        \n",
      "            If 'none', no edge is drawn; this can sometimes lead to unsightly\n",
      "            unpainted pixels between the hexagons.\n",
      "        \n",
      "            If *None*, draws outlines in the default color.\n",
      "        \n",
      "            If a matplotlib color arg, draws outlines in the specified color.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        object\n",
      "            a :class:`~matplotlib.collections.PolyCollection` instance; use\n",
      "            :meth:`~matplotlib.collections.PolyCollection.get_array` on\n",
      "            this :class:`~matplotlib.collections.PolyCollection` to get\n",
      "            the counts in each hexagon.\n",
      "        \n",
      "            If *marginals* is *True*, horizontal\n",
      "            bar and vertical bar (both PolyCollections) will be attached\n",
      "            to the return collection as attributes *hbar* and *vbar*.\n",
      "        \n",
      "        Notes\n",
      "        --------\n",
      "        The standard descriptions of all the\n",
      "        :class:`~matplotlib.collections.Collection` parameters:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    hist(x, bins=None, range=None, density=None, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False, normed=None, hold=None, data=None, **kwargs)\n",
      "        Plot a histogram.\n",
      "        \n",
      "        Compute and draw the histogram of *x*. The return value is a\n",
      "        tuple (*n*, *bins*, *patches*) or ([*n0*, *n1*, ...], *bins*,\n",
      "        [*patches0*, *patches1*,...]) if the input contains multiple\n",
      "        data.\n",
      "        \n",
      "        Multiple data can be provided via *x* as a list of datasets\n",
      "        of potentially different length ([*x0*, *x1*, ...]), or as\n",
      "        a 2-D ndarray in which each column is a dataset.  Note that\n",
      "        the ndarray form is transposed relative to the list form.\n",
      "        \n",
      "        Masked arrays are not supported at present.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : (n,) array or sequence of (n,) arrays\n",
      "            Input values, this takes either a single array or a sequency of\n",
      "            arrays which are not required to be of the same length\n",
      "        \n",
      "        bins : integer or sequence or 'auto', optional\n",
      "            If an integer is given, ``bins + 1`` bin edges are calculated and\n",
      "            returned, consistent with :func:`numpy.histogram`.\n",
      "        \n",
      "            If `bins` is a sequence, gives bin edges, including left edge of\n",
      "            first bin and right edge of last bin.  In this case, `bins` is\n",
      "            returned unmodified.\n",
      "        \n",
      "            All but the last (righthand-most) bin is half-open.  In other\n",
      "            words, if `bins` is::\n",
      "        \n",
      "                [1, 2, 3, 4]\n",
      "        \n",
      "            then the first bin is ``[1, 2)`` (including 1, but excluding 2) and\n",
      "            the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which\n",
      "            *includes* 4.\n",
      "        \n",
      "            Unequally spaced bins are supported if *bins* is a sequence.\n",
      "        \n",
      "            If Numpy 1.11 is installed, may also be ``'auto'``.\n",
      "        \n",
      "            Default is taken from the rcParam ``hist.bins``.\n",
      "        \n",
      "        range : tuple or None, optional\n",
      "            The lower and upper range of the bins. Lower and upper outliers\n",
      "            are ignored. If not provided, *range* is ``(x.min(), x.max())``.\n",
      "            Range has no effect if *bins* is a sequence.\n",
      "        \n",
      "            If *bins* is a sequence or *range* is specified, autoscaling\n",
      "            is based on the specified bin range instead of the\n",
      "            range of x.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        density : boolean, optional\n",
      "            If ``True``, the first element of the return tuple will\n",
      "            be the counts normalized to form a probability density, i.e.,\n",
      "            the area (or integral) under the histogram will sum to 1.\n",
      "            This is achieved by dividing the count by the number of\n",
      "            observations times the bin width and not dividing by the total\n",
      "            number of observations. If *stacked* is also ``True``, the sum of\n",
      "            the histograms is normalized to 1.\n",
      "        \n",
      "            Default is ``None`` for both *normed* and *density*. If either is\n",
      "            set, then that value will be used. If neither are set, then the\n",
      "            args will be treated as ``False``.\n",
      "        \n",
      "            If both *density* and *normed* are set an error is raised.\n",
      "        \n",
      "        weights : (n, ) array_like or None, optional\n",
      "            An array of weights, of the same shape as *x*.  Each value in *x*\n",
      "            only contributes its associated weight towards the bin count\n",
      "            (instead of 1).  If *normed* or *density* is ``True``,\n",
      "            the weights are normalized, so that the integral of the density\n",
      "            over the range remains 1.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        cumulative : boolean, optional\n",
      "            If ``True``, then a histogram is computed where each bin gives the\n",
      "            counts in that bin plus all bins for smaller values. The last bin\n",
      "            gives the total number of datapoints. If *normed* or *density*\n",
      "            is also ``True`` then the histogram is normalized such that the\n",
      "            last bin equals 1. If *cumulative* evaluates to less than 0\n",
      "            (e.g., -1), the direction of accumulation is reversed.\n",
      "            In this case, if *normed* and/or *density* is also ``True``, then\n",
      "            the histogram is normalized such that the first bin equals 1.\n",
      "        \n",
      "            Default is ``False``\n",
      "        \n",
      "        bottom : array_like, scalar, or None\n",
      "            Location of the bottom baseline of each bin.  If a scalar,\n",
      "            the base line for each bin is shifted by the same amount.\n",
      "            If an array, each bin is shifted independently and the length\n",
      "            of bottom must match the number of bins.  If None, defaults to 0.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        histtype : {'bar', 'barstacked', 'step',  'stepfilled'}, optional\n",
      "            The type of histogram to draw.\n",
      "        \n",
      "            - 'bar' is a traditional bar-type histogram.  If multiple data\n",
      "              are given the bars are aranged side by side.\n",
      "        \n",
      "            - 'barstacked' is a bar-type histogram where multiple\n",
      "              data are stacked on top of each other.\n",
      "        \n",
      "            - 'step' generates a lineplot that is by default\n",
      "              unfilled.\n",
      "        \n",
      "            - 'stepfilled' generates a lineplot that is by default\n",
      "              filled.\n",
      "        \n",
      "            Default is 'bar'\n",
      "        \n",
      "        align : {'left', 'mid', 'right'}, optional\n",
      "            Controls how the histogram is plotted.\n",
      "        \n",
      "                - 'left': bars are centered on the left bin edges.\n",
      "        \n",
      "                - 'mid': bars are centered between the bin edges.\n",
      "        \n",
      "                - 'right': bars are centered on the right bin edges.\n",
      "        \n",
      "            Default is 'mid'\n",
      "        \n",
      "        orientation : {'horizontal', 'vertical'}, optional\n",
      "            If 'horizontal', `~matplotlib.pyplot.barh` will be used for\n",
      "            bar-type histograms and the *bottom* kwarg will be the left edges.\n",
      "        \n",
      "        rwidth : scalar or None, optional\n",
      "            The relative width of the bars as a fraction of the bin width.  If\n",
      "            ``None``, automatically compute the width.\n",
      "        \n",
      "            Ignored if *histtype* is 'step' or 'stepfilled'.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        log : boolean, optional\n",
      "            If ``True``, the histogram axis will be set to a log scale. If\n",
      "            *log* is ``True`` and *x* is a 1D array, empty bins will be\n",
      "            filtered out and only the non-empty ``(n, bins, patches)``\n",
      "            will be returned.\n",
      "        \n",
      "            Default is ``False``\n",
      "        \n",
      "        color : color or array_like of colors or None, optional\n",
      "            Color spec or sequence of color specs, one per dataset.  Default\n",
      "            (``None``) uses the standard line color sequence.\n",
      "        \n",
      "            Default is ``None``\n",
      "        \n",
      "        label : string or None, optional\n",
      "            String, or sequence of strings to match multiple datasets.  Bar\n",
      "            charts yield multiple patches per dataset, but only the first gets\n",
      "            the label, so that the legend command will work as expected.\n",
      "        \n",
      "            default is ``None``\n",
      "        \n",
      "        stacked : boolean, optional\n",
      "            If ``True``, multiple data are stacked on top of each other If\n",
      "            ``False`` multiple data are aranged side by side if histtype is\n",
      "            'bar' or on top of each other if histtype is 'step'\n",
      "        \n",
      "            Default is ``False``\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        n : array or list of arrays\n",
      "            The values of the histogram bins. See *normed* or *density*\n",
      "            and *weights* for a description of the possible semantics.\n",
      "            If input *x* is an array, then this is an array of length\n",
      "            *nbins*. If input is a sequence arrays\n",
      "            ``[data1, data2,..]``, then this is a list of arrays with\n",
      "            the values of the histograms for each of the arrays in the\n",
      "            same order.\n",
      "        \n",
      "        bins : array\n",
      "            The edges of the bins. Length nbins + 1 (nbins left edges and right\n",
      "            edge of last bin).  Always a single array even when multiple data\n",
      "            sets are passed in.\n",
      "        \n",
      "        patches : list or list of lists\n",
      "            Silent list of individual patches used to create the histogram\n",
      "            or list of such list if multiple input datasets.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.patches.Patch` properties\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hist2d : 2D histograms\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'weights', 'x'.\n",
      "    \n",
      "    hist2d(x, y, bins=10, range=None, normed=False, weights=None, cmin=None, cmax=None, hold=None, data=None, **kwargs)\n",
      "        Make a 2D histogram plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y: array_like, shape (n, )\n",
      "            Input values\n",
      "        \n",
      "        bins: [None | int | [int, int] | array_like | [array, array]]\n",
      "        \n",
      "            The bin specification:\n",
      "        \n",
      "                - If int, the number of bins for the two dimensions\n",
      "                  (nx=ny=bins).\n",
      "        \n",
      "                - If [int, int], the number of bins in each dimension\n",
      "                  (nx, ny = bins).\n",
      "        \n",
      "                - If array_like, the bin edges for the two dimensions\n",
      "                  (x_edges=y_edges=bins).\n",
      "        \n",
      "                - If [array, array], the bin edges in each dimension\n",
      "                  (x_edges, y_edges = bins).\n",
      "        \n",
      "            The default value is 10.\n",
      "        \n",
      "        range : array_like shape(2, 2), optional, default: None\n",
      "             The leftmost and rightmost edges of the bins along each dimension\n",
      "             (if not specified explicitly in the bins parameters): [[xmin,\n",
      "             xmax], [ymin, ymax]]. All values outside of this range will be\n",
      "             considered outliers and not tallied in the histogram.\n",
      "        \n",
      "        normed : boolean, optional, default: False\n",
      "             Normalize histogram.\n",
      "        \n",
      "        weights : array_like, shape (n, ), optional, default: None\n",
      "            An array of values w_i weighing each sample (x_i, y_i).\n",
      "        \n",
      "        cmin : scalar, optional, default: None\n",
      "             All bins that has count less than cmin will not be displayed and\n",
      "             these count values in the return value count histogram will also\n",
      "             be set to nan upon return\n",
      "        \n",
      "        cmax : scalar, optional, default: None\n",
      "             All bins that has count more than cmax will not be displayed (set\n",
      "             to none before passing to imshow) and these count values in the\n",
      "             return value count histogram will also be set to nan upon return\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        The return value is ``(counts, xedges, yedges, Image)``.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        cmap : {Colormap, string}, optional\n",
      "            A :class:`matplotlib.colors.Colormap` instance.  If not set, use rc\n",
      "            settings.\n",
      "        \n",
      "        norm : Normalize, optional\n",
      "            A :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to ``[0, 1]``. If not set, defaults to\n",
      "            ``Normalize()``.\n",
      "        \n",
      "        vmin/vmax : {None, scalar}, optional\n",
      "            Arguments passed to the `Normalize` instance.\n",
      "        \n",
      "        alpha : ``0 <= scalar <= 1`` or ``None``, optional\n",
      "            The alpha blending value.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hist : 1D histogram\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Rendering the histogram with a logarithmic color scale is\n",
      "        accomplished by passing a :class:`colors.LogNorm` instance to\n",
      "        the *norm* keyword argument. Likewise, power-law normalization\n",
      "        (similar in effect to gamma correction) can be accomplished with\n",
      "        :class:`colors.PowerNorm`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'weights', 'x', 'y'.\n",
      "    \n",
      "    hlines(y, xmin, xmax, colors='k', linestyles='solid', label='', hold=None, data=None, **kwargs)\n",
      "        Plot horizontal lines at each `y` from `xmin` to `xmax`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        y : scalar or sequence of scalar\n",
      "            y-indexes where to plot the lines.\n",
      "        \n",
      "        xmin, xmax : scalar or 1D array_like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : array_like of colors, optional, default: 'k'\n",
      "        \n",
      "        linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional\n",
      "        \n",
      "        label : string, optional, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : `~matplotlib.collections.LineCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :  `~matplotlib.collections.LineCollection` properties.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        vlines : vertical lines\n",
      "        axhline: horizontal line across the axes\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'xmax', 'xmin', 'y'.\n",
      "    \n",
      "    hold(b=None)\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Set the hold state.  If *b* is None (default), toggle the\n",
      "        hold state, else set the hold state to boolean value *b*::\n",
      "        \n",
      "          hold()      # toggle hold\n",
      "          hold(True)  # hold is on\n",
      "          hold(False) # hold is off\n",
      "        \n",
      "        When *hold* is *True*, subsequent plot commands will add elements to\n",
      "        the current axes.  When *hold* is *False*, the current axes and\n",
      "        figure will be cleared on the next plot command.\n",
      "    \n",
      "    hot()\n",
      "        set the default colormap to hot and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    hsv()\n",
      "        set the default colormap to hsv and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    imread(*args, **kwargs)\n",
      "        Read an image from a file into an array.\n",
      "        \n",
      "        *fname* may be a string path, a valid URL, or a Python\n",
      "        file-like object.  If using a file object, it must be opened in binary\n",
      "        mode.\n",
      "        \n",
      "        If *format* is provided, will try to read file of that type,\n",
      "        otherwise the format is deduced from the filename.  If nothing can\n",
      "        be deduced, PNG is tried.\n",
      "        \n",
      "        Return value is a :class:`numpy.array`.  For grayscale images, the\n",
      "        return array is MxN.  For RGB images, the return value is MxNx3.\n",
      "        For RGBA images the return value is MxNx4.\n",
      "        \n",
      "        matplotlib can only read PNGs natively, but if `PIL\n",
      "        <http://www.pythonware.com/products/pil/>`_ is installed, it will\n",
      "        use it to load the image and return an array (if possible) which\n",
      "        can be used with :func:`~matplotlib.pyplot.imshow`. Note, URL strings\n",
      "        may not be compatible with PIL. Check the PIL documentation for more\n",
      "        information.\n",
      "    \n",
      "    imsave(*args, **kwargs)\n",
      "        Save an array as in image file.\n",
      "        \n",
      "        The output formats available depend on the backend being used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fname : str or file-like\n",
      "            Path string to a filename, or a Python file-like object.\n",
      "            If *format* is *None* and *fname* is a string, the output\n",
      "            format is deduced from the extension of the filename.\n",
      "        arr : array-like\n",
      "            An MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA) array.\n",
      "        vmin, vmax: [ None | scalar ]\n",
      "            *vmin* and *vmax* set the color scaling for the image by fixing the\n",
      "            values that map to the colormap color limits. If either *vmin*\n",
      "            or *vmax* is None, that limit is determined from the *arr*\n",
      "            min/max value.\n",
      "        cmap : matplotlib.colors.Colormap, optional\n",
      "            For example, ``cm.viridis``.  If ``None``, defaults to the\n",
      "            ``image.cmap`` rcParam.\n",
      "        format : str\n",
      "            One of the file extensions supported by the active backend.  Most\n",
      "            backends support png, pdf, ps, eps and svg.\n",
      "        origin : [ 'upper' | 'lower' ]\n",
      "            Indicates whether the ``(0, 0)`` index of the array is in the\n",
      "            upper left or lower left corner of the axes.  Defaults to the\n",
      "            ``image.origin`` rcParam.\n",
      "        dpi : int\n",
      "            The DPI to store in the metadata of the file.  This does not affect the\n",
      "            resolution of the output image.\n",
      "    \n",
      "    imshow(X, cmap=None, norm=None, aspect=None, interpolation=None, alpha=None, vmin=None, vmax=None, origin=None, extent=None, shape=None, filternorm=1, filterrad=4.0, imlim=None, resample=None, url=None, hold=None, data=None, **kwargs)\n",
      "        Display an image on the axes.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X : array_like, shape (n, m) or (n, m, 3) or (n, m, 4)\n",
      "            Display the image in `X` to current axes.  `X` may be an\n",
      "            array or a PIL image. If `X` is an array, it\n",
      "            can have the following shapes and types:\n",
      "        \n",
      "            - MxN -- values to be mapped (float or int)\n",
      "            - MxNx3 -- RGB (float or uint8)\n",
      "            - MxNx4 -- RGBA (float or uint8)\n",
      "        \n",
      "            The value for each component of MxNx3 and MxNx4 float arrays\n",
      "            should be in the range 0.0 to 1.0. MxN arrays are mapped\n",
      "            to colors based on the `norm` (mapping scalar to scalar)\n",
      "            and the `cmap` (mapping the normed scalar to a color).\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            If None, default to rc `image.cmap` value. `cmap` is ignored\n",
      "            if `X` is 3-D, directly specifying RGB(A) values.\n",
      "        \n",
      "        aspect : ['auto' | 'equal' | scalar], optional, default: None\n",
      "            If 'auto', changes the image aspect ratio to match that of the\n",
      "            axes.\n",
      "        \n",
      "            If 'equal', and `extent` is None, changes the axes aspect ratio to\n",
      "            match that of the image. If `extent` is not `None`, the axes\n",
      "            aspect ratio is changed to match that of the extent.\n",
      "        \n",
      "            If None, default to rc ``image.aspect`` value.\n",
      "        \n",
      "        interpolation : string, optional, default: None\n",
      "            Acceptable values are 'none', 'nearest', 'bilinear', 'bicubic',\n",
      "            'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',\n",
      "            'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc',\n",
      "            'lanczos'\n",
      "        \n",
      "            If `interpolation` is None, default to rc `image.interpolation`.\n",
      "            See also the `filternorm` and `filterrad` parameters.\n",
      "            If `interpolation` is 'none', then no interpolation is performed\n",
      "            on the Agg, ps and pdf backends. Other backends will fall back to\n",
      "            'nearest'.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional, default: None\n",
      "            A `~matplotlib.colors.Normalize` instance is used to scale\n",
      "            a 2-D float `X` input to the (0, 1) range for input to the\n",
      "            `cmap`. If `norm` is None, use the default func:`normalize`.\n",
      "            If `norm` is an instance of `~matplotlib.colors.NoNorm`,\n",
      "            `X` must be an array of integers that index directly into\n",
      "            the lookup table of the `cmap`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            `vmin` and `vmax` are used in conjunction with norm to normalize\n",
      "            luminance data.  Note if you pass a `norm` instance, your\n",
      "            settings for `vmin` and `vmax` will be ignored.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque)\n",
      "        \n",
      "        origin : ['upper' | 'lower'], optional, default: None\n",
      "            Place the [0,0] index of the array in the upper left or lower left\n",
      "            corner of the axes. If None, default to rc `image.origin`.\n",
      "        \n",
      "        extent : scalars (left, right, bottom, top), optional, default: None\n",
      "            The location, in data-coordinates, of the lower-left and\n",
      "            upper-right corners. If `None`, the image is positioned such that\n",
      "            the pixel centers fall on zero-based (row, column) indices.\n",
      "        \n",
      "        shape : scalars (columns, rows), optional, default: None\n",
      "            For raw buffer images\n",
      "        \n",
      "        filternorm : scalar, optional, default: 1\n",
      "            A parameter for the antigrain image resize filter.  From the\n",
      "            antigrain documentation, if `filternorm` = 1, the filter\n",
      "            normalizes integer values and corrects the rounding errors. It\n",
      "            doesn't do anything with the source floating point values, it\n",
      "            corrects only integers according to the rule of 1.0 which means\n",
      "            that any sum of pixel weights must be equal to 1.0.  So, the\n",
      "            filter function must produce a graph of the proper shape.\n",
      "        \n",
      "        filterrad : scalar, optional, default: 4.0\n",
      "            The filter radius for filters that have a radius parameter, i.e.\n",
      "            when interpolation is one of: 'sinc', 'lanczos' or 'blackman'\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        image : `~matplotlib.image.AxesImage`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.artist.Artist` properties.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        matshow : Plot a matrix or an array as an image.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Unless *extent* is used, pixel centers will be located at integer\n",
      "        coordinates. In other words: the origin will coincide with the center\n",
      "        of pixel (0, 0).\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    inferno()\n",
      "        set the default colormap to inferno and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    install_repl_displayhook()\n",
      "        Install a repl display hook so that any stale figure are automatically\n",
      "        redrawn when control is returned to the repl.\n",
      "        \n",
      "        This works with IPython terminals and kernels,\n",
      "        as well as vanilla python shells.\n",
      "    \n",
      "    ioff()\n",
      "        Turn interactive mode off.\n",
      "    \n",
      "    ion()\n",
      "        Turn interactive mode on.\n",
      "    \n",
      "    ishold()\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Return the hold status of the current axes.\n",
      "    \n",
      "    isinteractive()\n",
      "        Return status of interactive mode.\n",
      "    \n",
      "    jet()\n",
      "        set the default colormap to jet and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    legend(*args, **kwargs)\n",
      "        Places a legend on the axes.\n",
      "        \n",
      "        To make a legend for lines which already exist on the axes\n",
      "        (via plot for instance), simply call this function with an iterable\n",
      "        of strings, one for each legend item. For example::\n",
      "        \n",
      "            ax.plot([1, 2, 3])\n",
      "            ax.legend(['A simple line'])\n",
      "        \n",
      "        However, in order to keep the \"label\" and the legend element\n",
      "        instance together, it is preferable to specify the label either at\n",
      "        artist creation, or by calling the\n",
      "        :meth:`~matplotlib.artist.Artist.set_label` method on the artist::\n",
      "        \n",
      "            line, = ax.plot([1, 2, 3], label='Inline label')\n",
      "            # Overwrite the label by calling the method.\n",
      "            line.set_label('Label via method')\n",
      "            ax.legend()\n",
      "        \n",
      "        Specific lines can be excluded from the automatic legend element\n",
      "        selection by defining a label starting with an underscore.\n",
      "        This is default for all artists, so calling :meth:`legend` without\n",
      "        any arguments and without setting the labels manually will result in\n",
      "        no legend being drawn.\n",
      "        \n",
      "        For full control of which artists have a legend entry, it is possible\n",
      "        to pass an iterable of legend artists followed by an iterable of\n",
      "        legend labels respectively::\n",
      "        \n",
      "           legend((line1, line2, line3), ('label1', 'label2', 'label3'))\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        loc : int or string or pair of floats, default: 'upper right'\n",
      "            The location of the legend. Possible codes are:\n",
      "        \n",
      "                ===============   =============\n",
      "                Location String   Location Code\n",
      "                ===============   =============\n",
      "                'best'            0\n",
      "                'upper right'     1\n",
      "                'upper left'      2\n",
      "                'lower left'      3\n",
      "                'lower right'     4\n",
      "                'right'           5\n",
      "                'center left'     6\n",
      "                'center right'    7\n",
      "                'lower center'    8\n",
      "                'upper center'    9\n",
      "                'center'          10\n",
      "                ===============   =============\n",
      "        \n",
      "        \n",
      "            Alternatively can be a 2-tuple giving ``x, y`` of the lower-left\n",
      "            corner of the legend in axes coordinates (in which case\n",
      "            ``bbox_to_anchor`` will be ignored).\n",
      "        \n",
      "        bbox_to_anchor : `~.BboxBase` or pair of floats\n",
      "            Specify any arbitrary location for the legend in `bbox_transform`\n",
      "            coordinates (default Axes coordinates).\n",
      "        \n",
      "            For example, to put the legend's upper right hand corner in the\n",
      "            center of the axes the following keywords can be used::\n",
      "        \n",
      "               loc='upper right', bbox_to_anchor=(0.5, 0.5)\n",
      "        \n",
      "        ncol : integer\n",
      "            The number of columns that the legend has. Default is 1.\n",
      "        \n",
      "        prop : None or :class:`matplotlib.font_manager.FontProperties` or dict\n",
      "            The font properties of the legend. If None (default), the current\n",
      "            :data:`matplotlib.rcParams` will be used.\n",
      "        \n",
      "        fontsize : int or float or {'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'}\n",
      "            Controls the font size of the legend. If the value is numeric the\n",
      "            size will be the absolute font size in points. String values are\n",
      "            relative to the current default font size. This argument is only\n",
      "            used if `prop` is not specified.\n",
      "        \n",
      "        numpoints : None or int\n",
      "            The number of marker points in the legend when creating a legend\n",
      "            entry for a line/:class:`matplotlib.lines.Line2D`.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.numpoints`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        scatterpoints : None or int\n",
      "            The number of marker points in the legend when creating a legend\n",
      "            entry for a scatter plot/\n",
      "            :class:`matplotlib.collections.PathCollection`.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.scatterpoints`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        scatteryoffsets : iterable of floats\n",
      "            The vertical offset (relative to the font size) for the markers\n",
      "            created for a scatter plot legend entry. 0.0 is at the base the\n",
      "            legend text, and 1.0 is at the top. To draw all markers at the\n",
      "            same height, set to ``[0.5]``. Default ``[0.375, 0.5, 0.3125]``.\n",
      "        \n",
      "        markerscale : None or int or float\n",
      "            The relative size of legend markers compared with the originally\n",
      "            drawn ones. Default is ``None`` which will take the value from\n",
      "            the ``legend.markerscale`` :data:`rcParam <matplotlib.rcParams>`.\n",
      "        \n",
      "        markerfirst : bool\n",
      "            If *True*, legend marker is placed to the left of the legend label.\n",
      "            If *False*, legend marker is placed to the right of the legend\n",
      "            label.\n",
      "            Default is *True*.\n",
      "        \n",
      "        frameon : None or bool\n",
      "            Control whether the legend should be drawn on a patch (frame).\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.frameon`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        fancybox : None or bool\n",
      "            Control whether round edges should be enabled around\n",
      "            the :class:`~matplotlib.patches.FancyBboxPatch` which\n",
      "            makes up the legend's background.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.fancybox`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        shadow : None or bool\n",
      "            Control whether to draw a shadow behind the legend.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.shadow`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        framealpha : None or float\n",
      "            Control the alpha transparency of the legend's background.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.framealpha`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "            If shadow is activated and framealpha is ``None`` the\n",
      "            default value is being ignored.\n",
      "        \n",
      "        facecolor : None or \"inherit\" or a color spec\n",
      "            Control the legend's background color.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.facecolor`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "            If ``\"inherit\"``, it will take the ``axes.facecolor``\n",
      "            :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        edgecolor : None or \"inherit\" or a color spec\n",
      "            Control the legend's background patch edge color.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.edgecolor`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "            If ``\"inherit\"``, it will take the ``axes.edgecolor``\n",
      "            :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        mode : {\"expand\", None}\n",
      "            If `mode` is set to ``\"expand\"`` the legend will be horizontally\n",
      "            expanded to fill the axes area (or `bbox_to_anchor` if defines\n",
      "            the legend's size).\n",
      "        \n",
      "        bbox_transform : None or :class:`matplotlib.transforms.Transform`\n",
      "            The transform for the bounding box (`bbox_to_anchor`). For a value\n",
      "            of ``None`` (default) the Axes'\n",
      "            :data:`~matplotlib.axes.Axes.transAxes` transform will be used.\n",
      "        \n",
      "        title : str or None\n",
      "            The legend's title. Default is no title (``None``).\n",
      "        \n",
      "        borderpad : float or None\n",
      "            The fractional whitespace inside the legend border.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.borderpad`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        labelspacing : float or None\n",
      "            The vertical space between the legend entries.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.labelspacing`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        handlelength : float or None\n",
      "            The length of the legend handles.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.handlelength`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        handletextpad : float or None\n",
      "            The pad between the legend handle and text.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.handletextpad`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        borderaxespad : float or None\n",
      "            The pad between the axes and legend border.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.borderaxespad`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        columnspacing : float or None\n",
      "            The spacing between columns.\n",
      "            Measured in font-size units.\n",
      "            Default is ``None`` which will take the value from the\n",
      "            ``legend.columnspacing`` :data:`rcParam<matplotlib.rcParams>`.\n",
      "        \n",
      "        handler_map : dict or None\n",
      "            The custom dictionary mapping instances or types to a legend\n",
      "            handler. This `handler_map` updates the default handler map\n",
      "            found at :func:`matplotlib.legend.Legend.get_legend_handler_map`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        \n",
      "        :class:`matplotlib.legend.Legend` instance\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        Not all kinds of artist are supported by the legend command. See\n",
      "        :ref:`sphx_glr_tutorials_intermediate_legend_guide.py` for details.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        .. plot:: gallery/api/legend.py\n",
      "    \n",
      "    locator_params(axis='both', tight=None, **kwargs)\n",
      "        Control behavior of tick locators.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "        *axis*\n",
      "            ['x' | 'y' | 'both']  Axis on which to operate;\n",
      "            default is 'both'.\n",
      "        \n",
      "        *tight*\n",
      "            [True | False | None] Parameter passed to :meth:`autoscale_view`.\n",
      "            Default is None, for no change.\n",
      "        \n",
      "        Remaining keyword arguments are passed to directly to the\n",
      "        :meth:`~matplotlib.ticker.MaxNLocator.set_params` method.\n",
      "        \n",
      "        Typically one might want to reduce the maximum number\n",
      "        of ticks and use tight bounds when plotting small\n",
      "        subplots, for example::\n",
      "        \n",
      "            ax.locator_params(tight=True, nbins=4)\n",
      "        \n",
      "        Because the locator is involved in autoscaling,\n",
      "        :meth:`autoscale_view` is called automatically after\n",
      "        the parameters are changed.\n",
      "        \n",
      "        This presently works only for the\n",
      "        :class:`~matplotlib.ticker.MaxNLocator` used\n",
      "        by default on linear axes, but it may be generalized.\n",
      "    \n",
      "    loglog(*args, **kwargs)\n",
      "        Make a plot with log scaling on both the *x* and *y* axis.\n",
      "        \n",
      "        :func:`~matplotlib.pyplot.loglog` supports all the keyword\n",
      "        arguments of :func:`~matplotlib.pyplot.plot` and\n",
      "        :meth:`matplotlib.axes.Axes.set_xscale` /\n",
      "        :meth:`matplotlib.axes.Axes.set_yscale`.\n",
      "        \n",
      "        Notable keyword arguments:\n",
      "        \n",
      "          *basex*/*basey*: scalar > 1\n",
      "            Base of the *x*/*y* logarithm\n",
      "        \n",
      "          *subsx*/*subsy*: [ *None* | sequence ]\n",
      "            The location of the minor *x*/*y* ticks; *None* defaults\n",
      "            to autosubs, which depend on the number of decades in the\n",
      "            plot; see :meth:`matplotlib.axes.Axes.set_xscale` /\n",
      "            :meth:`matplotlib.axes.Axes.set_yscale` for details\n",
      "        \n",
      "          *nonposx*/*nonposy*: ['mask' | 'clip' ]\n",
      "            Non-positive values in *x* or *y* can be masked as\n",
      "            invalid, or clipped to a very small positive number\n",
      "        \n",
      "        The remaining valid kwargs are\n",
      "        :class:`~matplotlib.lines.Line2D` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float\n",
      "    \n",
      "    magma()\n",
      "        set the default colormap to magma and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    magnitude_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, scale=None, hold=None, data=None, **kwargs)\n",
      "        Plot the magnitude spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          magnitude_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                             pad_to=None, sides='default', **kwargs)\n",
      "        \n",
      "        Compute the magnitude spectrum of *x*.  Data is padded to a\n",
      "        length of *pad_to* and the windowing function *window* is applied to\n",
      "        the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            input signal (i.e. no padding).\n",
      "        \n",
      "        scale : [ 'default' | 'linear' | 'dB' ]\n",
      "            The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      "            'dB' returns the values in dB scale, i.e., the dB amplitude\n",
      "            (20 * log10). 'default' is 'linear'.\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the magnitude spectrum before scaling (real valued)\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*\n",
      "        \n",
      "        line : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` plots the power spectral density.`.\n",
      "        \n",
      "        :func:`angle_spectrum`\n",
      "            :func:`angle_spectrum` plots the angles of the corresponding\n",
      "            frequencies.\n",
      "        \n",
      "        :func:`phase_spectrum`\n",
      "            :func:`phase_spectrum` plots the phase (unwrapped angle) of the\n",
      "            corresponding frequencies.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the magnitude spectrum of segments within\n",
      "            the signal in a colormap.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    margins(*args, **kw)\n",
      "        Set or retrieve autoscaling margins.\n",
      "        \n",
      "        signatures::\n",
      "        \n",
      "            margins()\n",
      "        \n",
      "        returns xmargin, ymargin\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            margins(margin)\n",
      "        \n",
      "            margins(xmargin, ymargin)\n",
      "        \n",
      "            margins(x=xmargin, y=ymargin)\n",
      "        \n",
      "            margins(..., tight=False)\n",
      "        \n",
      "        All three forms above set the xmargin and ymargin parameters.\n",
      "        All keyword parameters are optional.  A single argument\n",
      "        specifies both xmargin and ymargin.  The *tight* parameter\n",
      "        is passed to :meth:`autoscale_view`, which is executed after\n",
      "        a margin is changed; the default here is *True*, on the\n",
      "        assumption that when margins are specified, no additional\n",
      "        padding to match tick marks is usually desired.  Setting\n",
      "        *tight* to *None* will preserve the previous setting.\n",
      "        \n",
      "        Specifying any margin changes only the autoscaling; for example,\n",
      "        if *xmargin* is not None, then *xmargin* times the X data\n",
      "        interval will be added to each end of that interval before\n",
      "        it is used in autoscaling.\n",
      "    \n",
      "    matshow(A, fignum=None, **kw)\n",
      "        Display an array as a matrix in a new figure window.\n",
      "        \n",
      "        The origin is set at the upper left hand corner and rows (first\n",
      "        dimension of the array) are displayed horizontally.  The aspect\n",
      "        ratio of the figure window is that of the array, unless this would\n",
      "        make an excessively short or narrow figure.\n",
      "        \n",
      "        Tick labels for the xaxis are placed on top.\n",
      "        \n",
      "        With the exception of *fignum*, keyword arguments are passed to\n",
      "        :func:`~matplotlib.pyplot.imshow`.  You may set the *origin*\n",
      "        kwarg to \"lower\" if you want the first row in the array to be\n",
      "        at the bottom instead of the top.\n",
      "        \n",
      "        \n",
      "        *fignum*: [ None | integer | False ]\n",
      "          By default, :func:`matshow` creates a new figure window with\n",
      "          automatic numbering.  If *fignum* is given as an integer, the\n",
      "          created figure will use this figure number.  Because of how\n",
      "          :func:`matshow` tries to set the figure aspect ratio to be the\n",
      "          one of the array, if you provide the number of an already\n",
      "          existing figure, strange things may happen.\n",
      "        \n",
      "          If *fignum* is *False* or 0, a new figure window will **NOT** be created.\n",
      "    \n",
      "    minorticks_off()\n",
      "        Remove minor ticks from the current plot.\n",
      "    \n",
      "    minorticks_on()\n",
      "        Display minor ticks on the current plot.\n",
      "        \n",
      "        Displaying minor ticks reduces performance; turn them off using\n",
      "        minorticks_off() if drawing speed is a problem.\n",
      "    \n",
      "    nipy_spectral()\n",
      "        set the default colormap to nipy_spectral and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    over(func, *args, **kwargs)\n",
      "        .. deprecated:: 2.0\n",
      "            pyplot.hold is deprecated.\n",
      "            Future behavior will be consistent with the long-time default:\n",
      "            plot commands add elements without first clearing the\n",
      "            Axes and/or Figure.\n",
      "        \n",
      "        Call a function with hold(True).\n",
      "        \n",
      "        Calls::\n",
      "        \n",
      "          func(*args, **kwargs)\n",
      "        \n",
      "        with ``hold(True)`` and then restores the hold state.\n",
      "    \n",
      "    pause(interval)\n",
      "        Pause for *interval* seconds.\n",
      "        \n",
      "        If there is an active figure, it will be updated and displayed before the\n",
      "        pause, and the GUI event loop (if any) will run during the pause.\n",
      "        \n",
      "        This can be used for crude animation.  For more complex animation, see\n",
      "        :mod:`matplotlib.animation`.\n",
      "        \n",
      "        Note\n",
      "        ----\n",
      "        This function is experimental; its behavior may be changed or extended in a\n",
      "        future release.\n",
      "    \n",
      "    pcolor(*args, **kwargs)\n",
      "        Create a pseudocolor plot of a 2-D array.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "            pcolor(C, **kwargs)\n",
      "            pcolor(X, Y, C, **kwargs)\n",
      "        \n",
      "        pcolor can be very slow for large arrays; consider\n",
      "        using the similar but much faster\n",
      "        :func:`~matplotlib.pyplot.pcolormesh` instead.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        C : array_like\n",
      "            An array of color values.\n",
      "        \n",
      "        X, Y : array_like, optional\n",
      "            If given, specify the (x, y) coordinates of the colored\n",
      "            quadrilaterals; the quadrilateral for ``C[i,j]`` has corners at::\n",
      "        \n",
      "                (X[i,   j],   Y[i,   j]),\n",
      "                (X[i,   j+1], Y[i,   j+1]),\n",
      "                (X[i+1, j],   Y[i+1, j]),\n",
      "                (X[i+1, j+1], Y[i+1, j+1])\n",
      "        \n",
      "            Ideally the dimensions of ``X`` and ``Y`` should be one greater\n",
      "            than those of ``C``; if the dimensions are the same, then the last\n",
      "            row and column of ``C`` will be ignored.\n",
      "        \n",
      "            Note that the column index corresponds to the\n",
      "            x-coordinate, and the row index corresponds to y; for\n",
      "            details, see the :ref:`Grid Orientation\n",
      "            <axes-pcolor-grid-orientation>` section below.\n",
      "        \n",
      "            If either or both of ``X`` and ``Y`` are 1-D arrays or column\n",
      "            vectors, they will be expanded as needed into the appropriate 2-D\n",
      "            arrays, making a rectangular grid.\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            If `None`, default to rc settings.\n",
      "        \n",
      "        norm : `matplotlib.colors.Normalize`, optional, default: None\n",
      "            An instance is used to scale luminance data to (0, 1).\n",
      "            If `None`, defaults to :func:`normalize`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            ``vmin`` and ``vmax`` are used in conjunction with ``norm`` to\n",
      "            normalize luminance data.  If either is `None`, it is autoscaled to\n",
      "            the respective min or max of the color array ``C``.  If not `None`,\n",
      "            ``vmin`` or ``vmax`` passed in here override any pre-existing\n",
      "            values supplied in the ``norm`` instance.\n",
      "        \n",
      "        edgecolors : {None, 'none', color, color sequence}\n",
      "            If None, the rc setting is used by default.\n",
      "            If 'none', edges will not be visible.\n",
      "            An mpl color or sequence of colors will set the edge color.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque).\n",
      "        \n",
      "        snap : bool, optional, default: False\n",
      "            Whether to snap the mesh to pixel boundaries.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        collection : `matplotlib.collections.Collection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        antialiaseds : bool, optional, default: False\n",
      "            The default ``antialiaseds`` is False if the default\n",
      "            ``edgecolors=\"none\"`` is used.  This eliminates artificial lines\n",
      "            at patch boundaries, and works regardless of the value of alpha.\n",
      "            If ``edgecolors`` is not \"none\", then the default ``antialiaseds``\n",
      "            is taken from ``rcParams['patch.antialiased']``, which defaults to\n",
      "            True. Stroking the edges may be preferred if ``alpha`` is 1, but\n",
      "            will cause artifacts otherwise.\n",
      "        \n",
      "        **kwargs :\n",
      "        \n",
      "            Any unused keyword arguments are passed along to the\n",
      "            `~matplotlib.collections.PolyCollection` constructor:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        pcolormesh : for an explanation of the differences between\n",
      "            pcolor and pcolormesh.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. _axes-pcolor-grid-orientation:\n",
      "        \n",
      "        ``X``, ``Y`` and ``C`` may be masked arrays. If either C[i, j], or one\n",
      "        of the vertices surrounding C[i,j] (``X`` or ``Y`` at [i, j], [i+1, j],\n",
      "        [i, j+1], [i+1, j+1]) is masked, nothing is plotted.\n",
      "        \n",
      "        The grid orientation follows the MATLAB convention: an array ``C`` with\n",
      "        shape (nrows, ncolumns) is plotted with the column number as ``X`` and\n",
      "        the row number as ``Y``, increasing up; hence it is plotted the way the\n",
      "        array would be printed, except that the ``Y`` axis is reversed. That\n",
      "        is, ``C`` is taken as ``C`` (y, x).\n",
      "        \n",
      "        Similarly for :func:`meshgrid`::\n",
      "        \n",
      "            x = np.arange(5)\n",
      "            y = np.arange(3)\n",
      "            X, Y = np.meshgrid(x, y)\n",
      "        \n",
      "        is equivalent to::\n",
      "        \n",
      "            X = array([[0, 1, 2, 3, 4],\n",
      "                       [0, 1, 2, 3, 4],\n",
      "                       [0, 1, 2, 3, 4]])\n",
      "        \n",
      "            Y = array([[0, 0, 0, 0, 0],\n",
      "                       [1, 1, 1, 1, 1],\n",
      "                       [2, 2, 2, 2, 2]])\n",
      "        \n",
      "        so if you have::\n",
      "        \n",
      "            C = rand(len(x), len(y))\n",
      "        \n",
      "        then you need to transpose C::\n",
      "        \n",
      "            pcolor(X, Y, C.T)\n",
      "        \n",
      "        or::\n",
      "        \n",
      "            pcolor(C.T)\n",
      "        \n",
      "        MATLAB :func:`pcolor` always discards the last row and column of ``C``,\n",
      "        but Matplotlib displays the last row and column if ``X`` and ``Y`` are\n",
      "        not specified, or if ``X`` and ``Y`` have one more row and column than\n",
      "        ``C``.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    pcolormesh(*args, **kwargs)\n",
      "        Plot a quadrilateral mesh.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          pcolormesh(C)\n",
      "          pcolormesh(X, Y, C)\n",
      "          pcolormesh(C, **kwargs)\n",
      "        \n",
      "        Create a pseudocolor plot of a 2-D array.\n",
      "        \n",
      "        pcolormesh is similar to :func:`~matplotlib.pyplot.pcolor`,\n",
      "        but uses a different mechanism and returns a different\n",
      "        object; pcolor returns a\n",
      "        :class:`~matplotlib.collections.PolyCollection` but pcolormesh\n",
      "        returns a\n",
      "        :class:`~matplotlib.collections.QuadMesh`.  It is much faster,\n",
      "        so it is almost always preferred for large arrays.\n",
      "        \n",
      "        *C* may be a masked array, but *X* and *Y* may not.  Masked\n",
      "        array support is implemented via *cmap* and *norm*; in\n",
      "        contrast, :func:`~matplotlib.pyplot.pcolor` simply does not\n",
      "        draw quadrilaterals with masked colors or vertices.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A :class:`matplotlib.colors.Colormap` instance. If *None*, use\n",
      "            rc settings.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance is used to\n",
      "            scale luminance data to 0,1. If *None*, defaults to\n",
      "            :func:`normalize`.\n",
      "        \n",
      "          *vmin*/*vmax*: [ *None* | scalar ]\n",
      "            *vmin* and *vmax* are used in conjunction with *norm* to\n",
      "            normalize luminance data.  If either is *None*, it\n",
      "            is autoscaled to the respective min or max\n",
      "            of the color array *C*.  If not *None*, *vmin* or\n",
      "            *vmax* passed in here override any pre-existing values\n",
      "            supplied in the *norm* instance.\n",
      "        \n",
      "          *shading*: [ 'flat' | 'gouraud' ]\n",
      "            'flat' indicates a solid color for each quad.  When\n",
      "            'gouraud', each quad will be Gouraud shaded.  When gouraud\n",
      "            shading, edgecolors is ignored.\n",
      "        \n",
      "          *edgecolors*: [*None* | ``'None'`` | ``'face'`` | color |\n",
      "                         color sequence]\n",
      "        \n",
      "            If *None*, the rc setting is used by default.\n",
      "        \n",
      "            If ``'None'``, edges will not be visible.\n",
      "        \n",
      "            If ``'face'``, edges will have the same color as the faces.\n",
      "        \n",
      "            An mpl color or sequence of colors will set the edge color\n",
      "        \n",
      "          *alpha*: ``0 <= scalar <= 1``  or *None*\n",
      "            the alpha blending value\n",
      "        \n",
      "        Return value is a :class:`matplotlib.collections.QuadMesh`\n",
      "        object.\n",
      "        \n",
      "        kwargs can be used to control the\n",
      "        :class:`matplotlib.collections.QuadMesh` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`~matplotlib.pyplot.pcolor`\n",
      "                For an explanation of the grid orientation\n",
      "                (:ref:`Grid Orientation <axes-pcolor-grid-orientation>`)\n",
      "                and the expansion of 1-D *X* and/or *Y* to 2-D arrays.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    phase_spectrum(x, Fs=None, Fc=None, window=None, pad_to=None, sides=None, hold=None, data=None, **kwargs)\n",
      "        Plot the phase spectrum.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          phase_spectrum(x, Fs=2, Fc=0,  window=mlab.window_hanning,\n",
      "                         pad_to=None, sides='default', **kwargs)\n",
      "        \n",
      "        Compute the phase spectrum (unwrapped angle spectrum) of *x*.\n",
      "        Data is padded to a length of *pad_to* and the windowing function\n",
      "        *window* is applied to the signal.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  While not increasing the actual resolution of\n",
      "            the spectrum (the minimum distance between resolvable peaks),\n",
      "            this can give more points in the plot, allowing for more\n",
      "            detail. This corresponds to the *n* parameter in the call to fft().\n",
      "            The default is None, which sets *pad_to* equal to the length of the\n",
      "            input signal (i.e. no padding).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 1-D array\n",
      "            The values for the phase spectrum in radians (real valued)\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *spectrum*\n",
      "        \n",
      "        line : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`magnitude_spectrum` plots the magnitudes of the\n",
      "            corresponding frequencies.\n",
      "        \n",
      "        :func:`angle_spectrum`\n",
      "            :func:`angle_spectrum` plots the wrapped version of this function.\n",
      "        \n",
      "        :func:`specgram`\n",
      "            :func:`specgram` can plot the phase spectrum of segments within the\n",
      "            signal in a colormap.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    pie(x, explode=None, labels=None, colors=None, autopct=None, pctdistance=0.6, shadow=False, labeldistance=1.1, startangle=None, radius=None, counterclock=True, wedgeprops=None, textprops=None, center=(0, 0), frame=False, rotatelabels=False, hold=None, data=None)\n",
      "        Plot a pie chart.\n",
      "        \n",
      "        Make a pie chart of array *x*.  The fractional area of each\n",
      "        wedge is given by ``x/sum(x)``.  If ``sum(x) <= 1``, then the\n",
      "        values of x give the fractional area directly and the array\n",
      "        will not be normalized.  The wedges are plotted\n",
      "        counterclockwise, by default starting from the x-axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array-like\n",
      "            The input array used to make the pie chart.\n",
      "        \n",
      "        explode : array-like, optional, default: None\n",
      "            If not *None*, is a ``len(x)`` array which specifies the\n",
      "            fraction of the radius with which to offset each wedge.\n",
      "        \n",
      "        labels : list, optional, default: None\n",
      "            A sequence of strings providing the labels for each wedge\n",
      "        \n",
      "        colors : array-like, optional, default: None\n",
      "            A sequence of matplotlib color args through which the pie chart\n",
      "            will cycle.  If `None`, will use the colors in the currently\n",
      "            active cycle.\n",
      "        \n",
      "        autopct : None (default), string, or function, optional\n",
      "            If not *None*, is a string or function used to label the wedges\n",
      "            with their numeric value.  The label will be placed inside the\n",
      "            wedge.  If it is a format string, the label will be ``fmt%pct``.\n",
      "            If it is a function, it will be called.\n",
      "        \n",
      "        pctdistance : float, optional, default: 0.6\n",
      "            The ratio between the center of each pie slice and the\n",
      "            start of the text generated by *autopct*.  Ignored if\n",
      "            *autopct* is *None*.\n",
      "        \n",
      "        shadow : bool, optional, default: False\n",
      "            Draw a shadow beneath the pie.\n",
      "        \n",
      "        labeldistance : float, optional, default: 1.1\n",
      "            The radial distance at which the pie labels are drawn\n",
      "        \n",
      "        startangle : float, optional, default: None\n",
      "            If not *None*, rotates the start of the pie chart by *angle*\n",
      "            degrees counterclockwise from the x-axis.\n",
      "        \n",
      "        radius : float, optional, default: None\n",
      "            The radius of the pie, if *radius* is *None* it will be set to 1.\n",
      "        \n",
      "        counterclock : bool, optional, default: True\n",
      "            Specify fractions direction, clockwise or counterclockwise.\n",
      "        \n",
      "        wedgeprops : dict, optional, default: None\n",
      "            Dict of arguments passed to the wedge objects making the pie.\n",
      "            For example, you can pass in``wedgeprops = {'linewidth': 3}``\n",
      "            to set the width of the wedge border lines equal to 3.\n",
      "            For more details, look at the doc/arguments of the wedge object.\n",
      "            By default ``clip_on=False``.\n",
      "        \n",
      "        textprops : dict, optional, default: None\n",
      "            Dict of arguments to pass to the text objects.\n",
      "        \n",
      "        center :  list of float, optional, default: (0, 0)\n",
      "            Center position of the chart. Takes value (0, 0) or is a\n",
      "            sequence of 2 scalars.\n",
      "        \n",
      "        frame : bool, optional, default: False\n",
      "            Plot axes frame with the chart if true.\n",
      "        \n",
      "        rotatelabels : bool, optional, default: False\n",
      "            Rotate each label to the angle of the corresponding slice if true.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        patches : list\n",
      "            A sequence of :class:`matplotlib.patches.Wedge` instances\n",
      "        \n",
      "        texts : list\n",
      "            A is a list of the label :class:`matplotlib.text.Text` instances.\n",
      "        \n",
      "        autotexts : list\n",
      "            A is a list of :class:`~matplotlib.text.Text` instances for the\n",
      "            numeric labels. Is returned only if parameter *autopct* is\n",
      "            not *None*.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The pie chart will probably look best if the figure and axes are\n",
      "        square, or the Axes aspect is equal.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'explode', 'labels', 'x'.\n",
      "    \n",
      "    pink()\n",
      "        set the default colormap to pink and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    plasma()\n",
      "        set the default colormap to plasma and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    plot(*args, **kwargs)\n",
      "        Plot lines and/or markers to the\n",
      "        :class:`~matplotlib.axes.Axes`.  *args* is a variable length\n",
      "        argument, allowing for multiple *x*, *y* pairs with an\n",
      "        optional format string.  For example, each of the following is\n",
      "        legal::\n",
      "        \n",
      "            plot(x, y)        # plot x and y using default line style and color\n",
      "            plot(x, y, 'bo')  # plot x and y using blue circle markers\n",
      "            plot(y)           # plot y using x as index array 0..N-1\n",
      "            plot(y, 'r+')     # ditto, but with red plusses\n",
      "        \n",
      "        If *x* and/or *y* is 2-dimensional, then the corresponding columns\n",
      "        will be plotted.\n",
      "        \n",
      "        If used with labeled data, make sure that the color spec is not\n",
      "        included as an element in data, as otherwise the last case\n",
      "        ``plot(\"v\",\"r\", data={\"v\":..., \"r\":...)``\n",
      "        can be interpreted as the first case which would do ``plot(v, r)``\n",
      "        using the default line style and color.\n",
      "        \n",
      "        If not used with labeled data (i.e., without a data argument),\n",
      "        an arbitrary number of *x*, *y*, *fmt* groups can be specified, as in::\n",
      "        \n",
      "            a.plot(x1, y1, 'g^', x2, y2, 'g-')\n",
      "        \n",
      "        Return value is a list of lines that were added.\n",
      "        \n",
      "        By default, each line is assigned a different style specified by a\n",
      "        'style cycle'.  To change this behavior, you can edit the\n",
      "        axes.prop_cycle rcParam.\n",
      "        \n",
      "        The following format string characters are accepted to control\n",
      "        the line style or marker:\n",
      "        \n",
      "        ================    ===============================\n",
      "        character           description\n",
      "        ================    ===============================\n",
      "        ``'-'``             solid line style\n",
      "        ``'--'``            dashed line style\n",
      "        ``'-.'``            dash-dot line style\n",
      "        ``':'``             dotted line style\n",
      "        ``'.'``             point marker\n",
      "        ``','``             pixel marker\n",
      "        ``'o'``             circle marker\n",
      "        ``'v'``             triangle_down marker\n",
      "        ``'^'``             triangle_up marker\n",
      "        ``'<'``             triangle_left marker\n",
      "        ``'>'``             triangle_right marker\n",
      "        ``'1'``             tri_down marker\n",
      "        ``'2'``             tri_up marker\n",
      "        ``'3'``             tri_left marker\n",
      "        ``'4'``             tri_right marker\n",
      "        ``'s'``             square marker\n",
      "        ``'p'``             pentagon marker\n",
      "        ``'*'``             star marker\n",
      "        ``'h'``             hexagon1 marker\n",
      "        ``'H'``             hexagon2 marker\n",
      "        ``'+'``             plus marker\n",
      "        ``'x'``             x marker\n",
      "        ``'D'``             diamond marker\n",
      "        ``'d'``             thin_diamond marker\n",
      "        ``'|'``             vline marker\n",
      "        ``'_'``             hline marker\n",
      "        ================    ===============================\n",
      "        \n",
      "        \n",
      "        The following color abbreviations are supported:\n",
      "        \n",
      "        ==========  ========\n",
      "        character   color\n",
      "        ==========  ========\n",
      "        'b'         blue\n",
      "        'g'         green\n",
      "        'r'         red\n",
      "        'c'         cyan\n",
      "        'm'         magenta\n",
      "        'y'         yellow\n",
      "        'k'         black\n",
      "        'w'         white\n",
      "        ==========  ========\n",
      "        \n",
      "        In addition, you can specify colors in many weird and\n",
      "        wonderful ways, including full names (``'green'``), hex\n",
      "        strings (``'#008000'``), RGB or RGBA tuples (``(0,1,0,1)``) or\n",
      "        grayscale intensities as a string (``'0.8'``).  Of these, the\n",
      "        string specifications can be used in place of a ``fmt`` group,\n",
      "        but the tuple forms can be used only as ``kwargs``.\n",
      "        \n",
      "        Line styles and colors are combined in a single format string, as in\n",
      "        ``'bo'`` for blue circles.\n",
      "        \n",
      "        The *kwargs* can be used to set line properties (any property that has\n",
      "        a ``set_*`` method).  You can use this to set a line label (for auto\n",
      "        legends), linewidth, anitialising, marker face color, etc.  Here is an\n",
      "        example::\n",
      "        \n",
      "            plot([1,2,3], [1,2,3], 'go-', label='line 1', linewidth=2)\n",
      "            plot([1,2,3], [1,4,9], 'rs',  label='line 2')\n",
      "            axis([0, 4, 0, 10])\n",
      "            legend()\n",
      "        \n",
      "        If you make multiple lines with one plot command, the kwargs\n",
      "        apply to all those lines, e.g.::\n",
      "        \n",
      "            plot(x1, y1, x2, y2, antialiased=False)\n",
      "        \n",
      "        Neither line will be antialiased.\n",
      "        \n",
      "        You do not need to use format strings, which are just\n",
      "        abbreviations.  All of the line properties can be controlled\n",
      "        by keyword arguments.  For example, you can set the color,\n",
      "        marker, linestyle, and markercolor with::\n",
      "        \n",
      "            plot(x, y, color='green', linestyle='dashed', marker='o',\n",
      "                 markerfacecolor='blue', markersize=12).\n",
      "        \n",
      "        See :class:`~matplotlib.lines.Line2D` for details.\n",
      "        \n",
      "        The kwargs are :class:`~matplotlib.lines.Line2D` properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        kwargs *scalex* and *scaley*, if defined, are passed on to\n",
      "        :meth:`~matplotlib.axes.Axes.autoscale_view` to determine\n",
      "        whether the *x* and *y* axes are autoscaled; the default is\n",
      "        *True*.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    plot_date(x, y, fmt='o', tz=None, xdate=True, ydate=False, hold=None, data=None, **kwargs)\n",
      "        A plot with data that contains dates.\n",
      "        \n",
      "        Similar to the :func:`~matplotlib.pyplot.plot` command, except\n",
      "        the *x* or *y* (or both) data is considered to be dates, and the\n",
      "        axis is labeled accordingly.\n",
      "        \n",
      "        *x* and/or *y* can be a sequence of dates represented as float\n",
      "        days since 0001-01-01 UTC.\n",
      "        \n",
      "        Note if you are using custom date tickers and formatters, it\n",
      "        may be necessary to set the formatters/locators after the call\n",
      "        to :meth:`plot_date` since :meth:`plot_date` will set the\n",
      "        default tick locator to\n",
      "        :class:`matplotlib.dates.AutoDateLocator` (if the tick\n",
      "        locator is not already set to a\n",
      "        :class:`matplotlib.dates.DateLocator` instance) and the\n",
      "        default tick formatter to\n",
      "        :class:`matplotlib.dates.AutoDateFormatter` (if the tick\n",
      "        formatter is not already set to a\n",
      "        :class:`matplotlib.dates.DateFormatter` instance).\n",
      "        \n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fmt : string\n",
      "            The plot format string.\n",
      "        \n",
      "        tz : [ *None* | timezone string | :class:`tzinfo` instance]\n",
      "            The time zone to use in labeling dates. If *None*, defaults to rc\n",
      "            value.\n",
      "        \n",
      "        xdate : boolean\n",
      "            If *True*, the *x*-axis will be labeled with dates.\n",
      "        \n",
      "        ydate : boolean\n",
      "            If *True*, the *y*-axis will be labeled with dates.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines\n",
      "        \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        matplotlib.dates : helper functions on dates\n",
      "        matplotlib.dates.date2num : how to convert dates to num\n",
      "        matplotlib.dates.num2date : how to convert num to dates\n",
      "        matplotlib.dates.drange : how floating point dates\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    plotfile(fname, cols=(0,), plotfuncs=None, comments='#', skiprows=0, checkrows=5, delimiter=',', names=None, subplots=True, newfig=True, **kwargs)\n",
      "        Plot the data in a file.\n",
      "        \n",
      "        *cols* is a sequence of column identifiers to plot.  An identifier\n",
      "        is either an int or a string.  If it is an int, it indicates the\n",
      "        column number.  If it is a string, it indicates the column header.\n",
      "        matplotlib will make column headers lower case, replace spaces with\n",
      "        underscores, and remove all illegal characters; so ``'Adj Close*'``\n",
      "        will have name ``'adj_close'``.\n",
      "        \n",
      "        - If len(*cols*) == 1, only that column will be plotted on the *y* axis.\n",
      "        \n",
      "        - If len(*cols*) > 1, the first element will be an identifier for\n",
      "          data for the *x* axis and the remaining elements will be the\n",
      "          column indexes for multiple subplots if *subplots* is *True*\n",
      "          (the default), or for lines in a single subplot if *subplots*\n",
      "          is *False*.\n",
      "        \n",
      "        *plotfuncs*, if not *None*, is a dictionary mapping identifier to\n",
      "        an :class:`~matplotlib.axes.Axes` plotting function as a string.\n",
      "        Default is 'plot', other choices are 'semilogy', 'fill', 'bar',\n",
      "        etc.  You must use the same type of identifier in the *cols*\n",
      "        vector as you use in the *plotfuncs* dictionary, e.g., integer\n",
      "        column numbers in both or column names in both. If *subplots*\n",
      "        is *False*, then including any function such as 'semilogy'\n",
      "        that changes the axis scaling will set the scaling for all\n",
      "        columns.\n",
      "        \n",
      "        *comments*, *skiprows*, *checkrows*, *delimiter*, and *names*\n",
      "        are all passed on to :func:`matplotlib.pylab.csv2rec` to\n",
      "        load the data into a record array.\n",
      "        \n",
      "        If *newfig* is *True*, the plot always will be made in a new figure;\n",
      "        if *False*, it will be made in the current figure if one exists,\n",
      "        else in a new figure.\n",
      "        \n",
      "        kwargs are passed on to plotting functions.\n",
      "        \n",
      "        Example usage::\n",
      "        \n",
      "          # plot the 2nd and 4th column against the 1st in two subplots\n",
      "          plotfile(fname, (0,1,3))\n",
      "        \n",
      "          # plot using column names; specify an alternate plot type for volume\n",
      "          plotfile(fname, ('date', 'volume', 'adj_close'),\n",
      "                                        plotfuncs={'volume': 'semilogy'})\n",
      "        \n",
      "        Note: plotfile is intended as a convenience for quickly plotting\n",
      "        data from flat files; it is not intended as an alternative\n",
      "        interface to general plotting with pyplot or matplotlib.\n",
      "    \n",
      "    plotting()\n",
      "        ============================ ======================================================================================================================================================================================\n",
      "        Function                     Description                                                                                                                                                                           \n",
      "        ============================ ======================================================================================================================================================================================\n",
      "        `acorr`                      Plot the autocorrelation of `x`.                                                                                                                                                      \n",
      "        `angle_spectrum`             Plot the angle spectrum.                                                                                                                                                              \n",
      "        `annotate`                   Annotate the point ``xy`` with text ``s``.                                                                                                                                            \n",
      "        `arrow`                      Add an arrow to the axes.                                                                                                                                                             \n",
      "        `autoscale`                  Autoscale the axis view to the data (toggle).                                                                                                                                         \n",
      "        `axes`                       Add an axes to the figure.                                                                                                                                                            \n",
      "        `axhline`                    Add a horizontal line across the axis.                                                                                                                                                \n",
      "        `axhspan`                    Add a horizontal span (rectangle) across the axis.                                                                                                                                    \n",
      "        `axis`                       Convenience method to get or set axis properties.                                                                                                                                     \n",
      "        `axvline`                    Add a vertical line across the axes.                                                                                                                                                  \n",
      "        `axvspan`                    Add a vertical span (rectangle) across the axes.                                                                                                                                      \n",
      "        `bar`                        Make a bar plot.                                                                                                                                                                      \n",
      "        `barbs`                      Plot a 2-D field of barbs.                                                                                                                                                            \n",
      "        `barh`                       Make a horizontal bar plot.                                                                                                                                                           \n",
      "        `box`                        Turn the axes box on or off.                                                                                                                                                          \n",
      "        `boxplot`                    Make a box and whisker plot.                                                                                                                                                          \n",
      "        `broken_barh`                Plot horizontal bars.                                                                                                                                                                 \n",
      "        `cla`                        Clear the current axes.                                                                                                                                                               \n",
      "        `clabel`                     Label a contour plot.                                                                                                                                                                 \n",
      "        `clf`                        Clear the current figure.                                                                                                                                                             \n",
      "        `clim`                       Set the color limits of the current image.                                                                                                                                            \n",
      "        `close`                      Close a figure window.                                                                                                                                                                \n",
      "        `cohere`                     Plot the coherence between *x* and *y*.                                                                                                                                               \n",
      "        `colorbar`                   Add a colorbar to a plot.                                                                                                                                                             \n",
      "        `contour`                    Plot contours.                                                                                                                                                                        \n",
      "        `contourf`                   Plot contours.                                                                                                                                                                        \n",
      "        `csd`                        Plot the cross-spectral density.                                                                                                                                                      \n",
      "        `delaxes`                    Remove an axes from the current figure.                                                                                                                                               \n",
      "        `draw`                       Redraw the current figure.                                                                                                                                                            \n",
      "        `errorbar`                   Plot an errorbar graph.                                                                                                                                                               \n",
      "        `eventplot`                  Plot identical parallel lines at the given positions.                                                                                                                                 \n",
      "        `figimage`                   Adds a non-resampled image to the figure.                                                                                                                                             \n",
      "        `figlegend`                  Place a legend in the figure.                                                                                                                                                         \n",
      "        `fignum_exists`                                                                                                                                                                                                    \n",
      "        `figtext`                    Add text to figure.                                                                                                                                                                   \n",
      "        `figure`                     Creates a new figure.                                                                                                                                                                 \n",
      "        `fill`                       Plot filled polygons.                                                                                                                                                                 \n",
      "        `fill_between`               Make filled polygons between two curves.                                                                                                                                              \n",
      "        `fill_betweenx`              Make filled polygons between two horizontal curves.                                                                                                                                   \n",
      "        `findobj`                    Find artist objects.                                                                                                                                                                  \n",
      "        `gca`                        Get the current :class:`~matplotlib.axes.Axes` instance on the     current figure matching the given keyword args, or create one.                                                     \n",
      "        `gcf`                        Get a reference to the current figure.                                                                                                                                                \n",
      "        `gci`                        Get the current colorable artist.                                                                                                                                                     \n",
      "        `get_figlabels`              Return a list of existing figure labels.                                                                                                                                              \n",
      "        `get_fignums`                Return a list of existing figure numbers.                                                                                                                                             \n",
      "        `grid`                       Turn the axes grids on or off.                                                                                                                                                        \n",
      "        `hexbin`                     Make a hexagonal binning plot.                                                                                                                                                        \n",
      "        `hist`                       Plot a histogram.                                                                                                                                                                     \n",
      "        `hist2d`                     Make a 2D histogram plot.                                                                                                                                                             \n",
      "        `hlines`                     Plot horizontal lines at each `y` from `xmin` to `xmax`.                                                                                                                              \n",
      "        `hold`                       ..                                                                                                                                                                                    \n",
      "        `imread`                     Read an image from a file into an array.                                                                                                                                              \n",
      "        `imsave`                     Save an array as in image file.                                                                                                                                                       \n",
      "        `imshow`                     Display an image on the axes.                                                                                                                                                         \n",
      "        `install_repl_displayhook`   Install a repl display hook so that any stale figure are automatically     redrawn when control is returned to the repl.                                                              \n",
      "        `ioff`                       Turn interactive mode off.                                                                                                                                                            \n",
      "        `ion`                        Turn interactive mode on.                                                                                                                                                             \n",
      "        `ishold`                     ..                                                                                                                                                                                    \n",
      "        `isinteractive`              Return status of interactive mode.                                                                                                                                                    \n",
      "        `legend`                     Places a legend on the axes.                                                                                                                                                          \n",
      "        `locator_params`             Control behavior of tick locators.                                                                                                                                                    \n",
      "        `loglog`                     Make a plot with log scaling on both the *x* and *y* axis.                                                                                                                            \n",
      "        `magnitude_spectrum`         Plot the magnitude spectrum.                                                                                                                                                          \n",
      "        `margins`                    Set or retrieve autoscaling margins.                                                                                                                                                  \n",
      "        `matshow`                    Display an array as a matrix in a new figure window.                                                                                                                                  \n",
      "        `minorticks_off`             Remove minor ticks from the current plot.                                                                                                                                             \n",
      "        `minorticks_on`              Display minor ticks on the current plot.                                                                                                                                              \n",
      "        `over`                       ..                                                                                                                                                                                    \n",
      "        `pause`                      Pause for *interval* seconds.                                                                                                                                                         \n",
      "        `pcolor`                     Create a pseudocolor plot of a 2-D array.                                                                                                                                             \n",
      "        `pcolormesh`                 Plot a quadrilateral mesh.                                                                                                                                                            \n",
      "        `phase_spectrum`             Plot the phase spectrum.                                                                                                                                                              \n",
      "        `pie`                        Plot a pie chart.                                                                                                                                                                     \n",
      "        `plot`                       Plot lines and/or markers to the :class:`~matplotlib.axes.Axes`.                                                                                                                      \n",
      "        `plot_date`                  A plot with data that contains dates.                                                                                                                                                 \n",
      "        `plotfile`                   Plot the data in a file.                                                                                                                                                              \n",
      "        `polar`                      Make a polar plot.                                                                                                                                                                    \n",
      "        `psd`                        Plot the power spectral density.                                                                                                                                                      \n",
      "        `quiver`                     Plot a 2-D field of arrows.                                                                                                                                                           \n",
      "        `quiverkey`                  Add a key to a quiver plot.                                                                                                                                                           \n",
      "        `rc`                         Set the current rc params.                                                                                                                                                            \n",
      "        `rc_context`                 Return a context manager for managing rc settings.                                                                                                                                    \n",
      "        `rcdefaults`                 Restore the rc params from Matplotlib's internal defaults.                                                                                                                            \n",
      "        `rgrids`                     Get or set the radial gridlines on a polar plot.                                                                                                                                      \n",
      "        `savefig`                    Save the current figure.                                                                                                                                                              \n",
      "        `sca`                        Set the current Axes instance to *ax*.                                                                                                                                                \n",
      "        `scatter`                    Make a scatter plot of `x` vs `y`.                                                                                                                                                    \n",
      "        `sci`                        Set the current image.                                                                                                                                                                \n",
      "        `semilogx`                   Make a plot with log scaling on the *x* axis.                                                                                                                                         \n",
      "        `semilogy`                   Make a plot with log scaling on the *y* axis.                                                                                                                                         \n",
      "        `set_cmap`                   Set the default colormap.                                                                                                                                                             \n",
      "        `setp`                       Set a property on an artist object.                                                                                                                                                   \n",
      "        `show`                       Display a figure.                                                                                                                                                                     \n",
      "        `specgram`                   Plot a spectrogram.                                                                                                                                                                   \n",
      "        `spy`                        Plot the sparsity pattern on a 2-D array.                                                                                                                                             \n",
      "        `stackplot`                  Draws a stacked area plot.                                                                                                                                                            \n",
      "        `stem`                       Create a stem plot.                                                                                                                                                                   \n",
      "        `step`                       Make a step plot.                                                                                                                                                                     \n",
      "        `streamplot`                 Draws streamlines of a vector flow.                                                                                                                                                   \n",
      "        `subplot`                    Return a subplot axes at the given grid position.                                                                                                                                     \n",
      "        `subplot2grid`               Create an axis at specific location inside a regular grid.                                                                                                                            \n",
      "        `subplot_tool`               Launch a subplot tool window for a figure.                                                                                                                                            \n",
      "        `subplots`                   Create a figure and a set of subplots      This utility wrapper makes it convenient to create common layouts of     subplots, including the enclosing figure object, in a single call.\n",
      "        `subplots_adjust`            Tune the subplot layout.                                                                                                                                                              \n",
      "        `suptitle`                   Add a centered title to the figure.                                                                                                                                                   \n",
      "        `switch_backend`             Switch the default backend.                                                                                                                                                           \n",
      "        `table`                      Add a table to the current axes.                                                                                                                                                      \n",
      "        `text`                       Add text to the axes.                                                                                                                                                                 \n",
      "        `thetagrids`                 Get or set the theta locations of the gridlines in a polar plot.                                                                                                                      \n",
      "        `tick_params`                Change the appearance of ticks and tick labels.                                                                                                                                       \n",
      "        `ticklabel_format`           Change the `~matplotlib.ticker.ScalarFormatter` used by default for linear axes.                                                                                                      \n",
      "        `tight_layout`               Automatically adjust subplot parameters to give specified padding.                                                                                                                    \n",
      "        `title`                      Set a title of the current axes.                                                                                                                                                      \n",
      "        `tricontour`                 Draw contours on an unstructured triangular grid.                                                                                                                                     \n",
      "        `tricontourf`                Draw contours on an unstructured triangular grid.                                                                                                                                     \n",
      "        `tripcolor`                  Create a pseudocolor plot of an unstructured triangular grid.                                                                                                                         \n",
      "        `triplot`                    Draw a unstructured triangular grid as lines and/or markers.                                                                                                                          \n",
      "        `twinx`                      Make a second axes that shares the *x*-axis.                                                                                                                                          \n",
      "        `twiny`                      Make a second axes that shares the *y*-axis.                                                                                                                                          \n",
      "        `uninstall_repl_displayhook` Uninstalls the matplotlib display hook.                                                                                                                                               \n",
      "        `violinplot`                 Make a violin plot.                                                                                                                                                                   \n",
      "        `vlines`                     Plot vertical lines.                                                                                                                                                                  \n",
      "        `xcorr`                      Plot the cross correlation between *x* and *y*.                                                                                                                                       \n",
      "        `xkcd`                       Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.                                                                                                                       \n",
      "        `xlabel`                     Set the *x* axis label of the current axis.                                                                                                                                           \n",
      "        `xlim`                       Get or set the *x* limits of the current axes.                                                                                                                                        \n",
      "        `xscale`                     Set the scaling of the *x*-axis.                                                                                                                                                      \n",
      "        `xticks`                     Get or set the *x*-limits of the current tick locations and labels.                                                                                                                   \n",
      "        `ylabel`                     Set the *y* axis label of the current axis.                                                                                                                                           \n",
      "        `ylim`                       Get or set the *y*-limits of the current axes.                                                                                                                                        \n",
      "        `yscale`                     Set the scaling of the *y*-axis.                                                                                                                                                      \n",
      "        `yticks`                     Get or set the *y*-limits of the current tick locations and labels.                                                                                                                   \n",
      "        ============================ ======================================================================================================================================================================================\n",
      "    \n",
      "    polar(*args, **kwargs)\n",
      "        Make a polar plot.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          polar(theta, r, **kwargs)\n",
      "        \n",
      "        Multiple *theta*, *r* arguments are supported, with format\n",
      "        strings, as in :func:`~matplotlib.pyplot.plot`.\n",
      "    \n",
      "    prism()\n",
      "        set the default colormap to prism and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    psd(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, pad_to=None, sides=None, scale_by_freq=None, return_line=None, hold=None, data=None, **kwargs)\n",
      "        Plot the power spectral density.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          psd(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "              window=mlab.window_hanning, noverlap=0, pad_to=None,\n",
      "              sides='default', scale_by_freq=None, return_line=None, **kwargs)\n",
      "        \n",
      "        The power spectral density :math:`P_{xx}` by Welch's average\n",
      "        periodogram method.  The vector *x* is divided into *NFFT* length\n",
      "        segments.  Each segment is detrended by function *detrend* and\n",
      "        windowed by function *window*.  *noverlap* gives the length of\n",
      "        the overlap between segments.  The :math:`|\\mathrm{fft}(i)|^2`\n",
      "        of each segment :math:`i` are averaged to compute :math:`P_{xx}`,\n",
      "        with a scaling to correct for power loss due to windowing.\n",
      "        \n",
      "        If len(*x*) < *NFFT*, it will be zero padded to *NFFT*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between segments.\n",
      "            The default value is 0 (no overlap).\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        return_line : bool\n",
      "            Whether to include the line object plotted in the returned values.\n",
      "            Default is False.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        Pxx : 1-D array\n",
      "            The values for the power spectrum `P_{xx}` before scaling\n",
      "            (real valued)\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the elements in *Pxx*\n",
      "        \n",
      "        line : a :class:`~matplotlib.lines.Line2D` instance\n",
      "            The line created by this function.\n",
      "            Only returned if *return_line* is True.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        For plotting, the power is plotted as\n",
      "        :math:`10\\log_{10}(P_{xx})` for decibels, though *Pxx* itself\n",
      "        is returned.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Bendat & Piersol -- Random Data: Analysis and Measurement Procedures,\n",
      "        John Wiley & Sons (1986)\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`specgram`\n",
      "            :func:`specgram` differs in the default overlap; in not returning\n",
      "            the mean of the segment periodograms; in returning the times of the\n",
      "            segments; and in plotting a colormap instead of a line.\n",
      "        \n",
      "        :func:`magnitude_spectrum`\n",
      "            :func:`magnitude_spectrum` plots the magnitude spectrum.\n",
      "        \n",
      "        :func:`csd`\n",
      "            :func:`csd` plots the spectral density between two signals.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    quiver(*args, **kw)\n",
      "        Plot a 2-D field of arrows.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          quiver(U, V, **kw)\n",
      "          quiver(U, V, C, **kw)\n",
      "          quiver(X, Y, U, V, **kw)\n",
      "          quiver(X, Y, U, V, C, **kw)\n",
      "        \n",
      "        *U* and *V* are the arrow data, *X* and *Y* set the location of the\n",
      "        arrows, and *C* sets the color of the arrows. These arguments may be 1-D or\n",
      "        2-D arrays or sequences.\n",
      "        \n",
      "        If *X* and *Y* are absent, they will be generated as a uniform grid.\n",
      "        If *U* and *V* are 2-D arrays and *X* and *Y* are 1-D, and if ``len(X)`` and\n",
      "        ``len(Y)`` match the column and row dimensions of *U*, then *X* and *Y* will be\n",
      "        expanded with :func:`numpy.meshgrid`.\n",
      "        \n",
      "        The default settings auto-scales the length of the arrows to a reasonable size.\n",
      "        To change this behavior see the *scale* and *scale_units* kwargs.\n",
      "        \n",
      "        The defaults give a slightly swept-back arrow; to make the head a\n",
      "        triangle, make *headaxislength* the same as *headlength*. To make the\n",
      "        arrow more pointed, reduce *headwidth* or increase *headlength* and\n",
      "        *headaxislength*. To make the head smaller relative to the shaft,\n",
      "        scale down all the head parameters. You will probably do best to leave\n",
      "        minshaft alone.\n",
      "        \n",
      "        *linewidths* and *edgecolors* can be used to customize the arrow\n",
      "        outlines.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        X : 1D or 2D array, sequence, optional\n",
      "            The x coordinates of the arrow locations\n",
      "        Y : 1D or 2D array, sequence, optional\n",
      "            The y coordinates of the arrow locations\n",
      "        U : 1D or 2D array or masked array, sequence\n",
      "            The x components of the arrow vectors\n",
      "        V : 1D or 2D array or masked array, sequence\n",
      "            The y components of the arrow vectors\n",
      "        C : 1D or 2D array, sequence, optional\n",
      "            The arrow colors\n",
      "        units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ]\n",
      "            The arrow dimensions (except for *length*) are measured in multiples of\n",
      "            this unit.\n",
      "        \n",
      "            'width' or 'height': the width or height of the axis\n",
      "        \n",
      "            'dots' or 'inches': pixels or inches, based on the figure dpi\n",
      "        \n",
      "            'x', 'y', or 'xy': respectively *X*, *Y*, or :math:`\\sqrt{X^2 + Y^2}`\n",
      "            in data units\n",
      "        \n",
      "            The arrows scale differently depending on the units.  For\n",
      "            'x' or 'y', the arrows get larger as one zooms in; for other\n",
      "            units, the arrow size is independent of the zoom state.  For\n",
      "            'width or 'height', the arrow size increases with the width and\n",
      "            height of the axes, respectively, when the window is resized;\n",
      "            for 'dots' or 'inches', resizing does not change the arrows.\n",
      "        angles : [ 'uv' | 'xy' ], array, optional\n",
      "            Method for determining the angle of the arrows. Default is 'uv'.\n",
      "        \n",
      "            'uv': the arrow axis aspect ratio is 1 so that\n",
      "            if *U*==*V* the orientation of the arrow on the plot is 45 degrees\n",
      "            counter-clockwise from the horizontal axis (positive to the right).\n",
      "        \n",
      "            'xy': arrows point from (x,y) to (x+u, y+v).\n",
      "            Use this for plotting a gradient field, for example.\n",
      "        \n",
      "            Alternatively, arbitrary angles may be specified as an array\n",
      "            of values in degrees, counter-clockwise from the horizontal axis.\n",
      "        \n",
      "            Note: inverting a data axis will correspondingly invert the\n",
      "            arrows only with ``angles='xy'``.\n",
      "        scale : None, float, optional\n",
      "            Number of data units per arrow length unit, e.g., m/s per plot width; a\n",
      "            smaller scale parameter makes the arrow longer. Default is *None*.\n",
      "        \n",
      "            If *None*, a simple autoscaling algorithm is used, based on the average\n",
      "            vector length and the number of vectors. The arrow length unit is given by\n",
      "            the *scale_units* parameter\n",
      "        scale_units : [ 'width' | 'height' | 'dots' | 'inches' | 'x' | 'y' | 'xy' ], None, optional\n",
      "            If the *scale* kwarg is *None*, the arrow length unit. Default is *None*.\n",
      "        \n",
      "            e.g. *scale_units* is 'inches', *scale* is 2.0, and\n",
      "            ``(u,v) = (1,0)``, then the vector will be 0.5 inches long.\n",
      "        \n",
      "            If *scale_units* is 'width'/'height', then the vector will be half the\n",
      "            width/height of the axes.\n",
      "        \n",
      "            If *scale_units* is 'x' then the vector will be 0.5 x-axis\n",
      "            units. To plot vectors in the x-y plane, with u and v having\n",
      "            the same units as x and y, use\n",
      "            ``angles='xy', scale_units='xy', scale=1``.\n",
      "        width : scalar, optional\n",
      "            Shaft width in arrow units; default depends on choice of units,\n",
      "            above, and number of vectors; a typical starting value is about\n",
      "            0.005 times the width of the plot.\n",
      "        headwidth : scalar, optional\n",
      "            Head width as multiple of shaft width, default is 3\n",
      "        headlength : scalar, optional\n",
      "            Head length as multiple of shaft width, default is 5\n",
      "        headaxislength : scalar, optional\n",
      "            Head length at shaft intersection, default is 4.5\n",
      "        minshaft : scalar, optional\n",
      "            Length below which arrow scales, in units of head length. Do not\n",
      "            set this to less than 1, or small arrows will look terrible!\n",
      "            Default is 1\n",
      "        minlength : scalar, optional\n",
      "            Minimum length as a multiple of shaft width; if an arrow length\n",
      "            is less than this, plot a dot (hexagon) of this diameter instead.\n",
      "            Default is 1.\n",
      "        pivot : [ 'tail' | 'mid' | 'middle' | 'tip' ], optional\n",
      "            The part of the arrow that is at the grid point; the arrow rotates\n",
      "            about this point, hence the name *pivot*.\n",
      "        color : [ color | color sequence ], optional\n",
      "            This is a synonym for the\n",
      "            :class:`~matplotlib.collections.PolyCollection` facecolor kwarg.\n",
      "            If *C* has been set, *color* has no effect.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional :class:`~matplotlib.collections.PolyCollection`\n",
      "        keyword arguments:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float or None \n",
      "          animated: bool \n",
      "          antialiased or antialiaseds: Boolean or sequence of booleans \n",
      "          array: ndarray\n",
      "          clim: a length 2 sequence of floats \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          cmap: a colormap or registered colormap name \n",
      "          color: matplotlib color arg or sequence of rgba tuples\n",
      "          contains: a callable function \n",
      "          edgecolor or edgecolors: matplotlib color spec or sequence of specs \n",
      "          facecolor or facecolors: matplotlib color spec or sequence of specs \n",
      "          figure: a `~.Figure` instance \n",
      "          gid: an id string \n",
      "          hatch: [ '/' | '\\\\' | '|' | '-' | '+' | 'x' | 'o' | 'O' | '.' | '*' ] \n",
      "          label: object \n",
      "          linestyle or dashes or linestyles: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or linewidths or lw: float or sequence of floats \n",
      "          norm: `~.Normalize`\n",
      "          offset_position: [ 'screen' | 'data' ] \n",
      "          offsets: float or sequence of floats \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          urls: List[str] or None \n",
      "          visible: bool \n",
      "          zorder: float \n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        quiverkey : Add a key to a quiver plot\n",
      "    \n",
      "    quiverkey(*args, **kw)\n",
      "        Add a key to a quiver plot.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          quiverkey(Q, X, Y, U, label, **kw)\n",
      "        \n",
      "        Arguments:\n",
      "        \n",
      "          *Q*:\n",
      "            The Quiver instance returned by a call to quiver.\n",
      "        \n",
      "          *X*, *Y*:\n",
      "            The location of the key; additional explanation follows.\n",
      "        \n",
      "          *U*:\n",
      "            The length of the key\n",
      "        \n",
      "          *label*:\n",
      "            A string with the length and units of the key\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *angle* = 0\n",
      "            The angle of the key arrow. Measured in degrees anti-clockwise from the\n",
      "            x-axis.\n",
      "        \n",
      "          *coordinates* = [ 'axes' | 'figure' | 'data' | 'inches' ]\n",
      "            Coordinate system and units for *X*, *Y*: 'axes' and 'figure' are\n",
      "            normalized coordinate systems with 0,0 in the lower left and 1,1\n",
      "            in the upper right; 'data' are the axes data coordinates (used for\n",
      "            the locations of the vectors in the quiver plot itself); 'inches'\n",
      "            is position in the figure in inches, with 0,0 at the lower left\n",
      "            corner.\n",
      "        \n",
      "          *color*:\n",
      "            overrides face and edge colors from *Q*.\n",
      "        \n",
      "          *labelpos* = [ 'N' | 'S' | 'E' | 'W' ]\n",
      "            Position the label above, below, to the right, to the left of the\n",
      "            arrow, respectively.\n",
      "        \n",
      "          *labelsep*:\n",
      "            Distance in inches between the arrow and the label.  Default is\n",
      "            0.1\n",
      "        \n",
      "          *labelcolor*:\n",
      "            defaults to default :class:`~matplotlib.text.Text` color.\n",
      "        \n",
      "          *fontproperties*:\n",
      "            A dictionary with keyword arguments accepted by the\n",
      "            :class:`~matplotlib.font_manager.FontProperties` initializer:\n",
      "            *family*, *style*, *variant*, *size*, *weight*\n",
      "        \n",
      "        Any additional keyword arguments are used to override vector\n",
      "        properties taken from *Q*.\n",
      "        \n",
      "        The positioning of the key depends on *X*, *Y*, *coordinates*, and\n",
      "        *labelpos*.  If *labelpos* is 'N' or 'S', *X*, *Y* give the position\n",
      "        of the middle of the key arrow.  If *labelpos* is 'E', *X*, *Y*\n",
      "        positions the head, and if *labelpos* is 'W', *X*, *Y* positions the\n",
      "        tail; in either of these two cases, *X*, *Y* is somewhere in the\n",
      "        middle of the arrow+label key object.\n",
      "    \n",
      "    rc(*args, **kwargs)\n",
      "        Set the current rc params.  Group is the grouping for the rc, e.g.,\n",
      "        for ``lines.linewidth`` the group is ``lines``, for\n",
      "        ``axes.facecolor``, the group is ``axes``, and so on.  Group may\n",
      "        also be a list or tuple of group names, e.g., (*xtick*, *ytick*).\n",
      "        *kwargs* is a dictionary attribute name/value pairs, e.g.,::\n",
      "        \n",
      "          rc('lines', linewidth=2, color='r')\n",
      "        \n",
      "        sets the current rc params and is equivalent to::\n",
      "        \n",
      "          rcParams['lines.linewidth'] = 2\n",
      "          rcParams['lines.color'] = 'r'\n",
      "        \n",
      "        The following aliases are available to save typing for interactive\n",
      "        users:\n",
      "        \n",
      "        =====   =================\n",
      "        Alias   Property\n",
      "        =====   =================\n",
      "        'lw'    'linewidth'\n",
      "        'ls'    'linestyle'\n",
      "        'c'     'color'\n",
      "        'fc'    'facecolor'\n",
      "        'ec'    'edgecolor'\n",
      "        'mew'   'markeredgewidth'\n",
      "        'aa'    'antialiased'\n",
      "        =====   =================\n",
      "        \n",
      "        Thus you could abbreviate the above rc command as::\n",
      "        \n",
      "              rc('lines', lw=2, c='r')\n",
      "        \n",
      "        \n",
      "        Note you can use python's kwargs dictionary facility to store\n",
      "        dictionaries of default parameters.  e.g., you can customize the\n",
      "        font rc as follows::\n",
      "        \n",
      "          font = {'family' : 'monospace',\n",
      "                  'weight' : 'bold',\n",
      "                  'size'   : 'larger'}\n",
      "        \n",
      "          rc('font', **font)  # pass in the font dict as kwargs\n",
      "        \n",
      "        This enables you to easily switch between several configurations.  Use\n",
      "        ``matplotlib.style.use('default')`` or :func:`~matplotlib.rcdefaults` to\n",
      "        restore the default rc params after changes.\n",
      "    \n",
      "    rc_context(rc=None, fname=None)\n",
      "        Return a context manager for managing rc settings.\n",
      "        \n",
      "        This allows one to do::\n",
      "        \n",
      "            with mpl.rc_context(fname='screen.rc'):\n",
      "                plt.plot(x, a)\n",
      "                with mpl.rc_context(fname='print.rc'):\n",
      "                    plt.plot(x, b)\n",
      "                plt.plot(x, c)\n",
      "        \n",
      "        The 'a' vs 'x' and 'c' vs 'x' plots would have settings from\n",
      "        'screen.rc', while the 'b' vs 'x' plot would have settings from\n",
      "        'print.rc'.\n",
      "        \n",
      "        A dictionary can also be passed to the context manager::\n",
      "        \n",
      "            with mpl.rc_context(rc={'text.usetex': True}, fname='screen.rc'):\n",
      "                plt.plot(x, a)\n",
      "        \n",
      "        The 'rc' dictionary takes precedence over the settings loaded from\n",
      "        'fname'.  Passing a dictionary only is also valid. For example a\n",
      "        common usage is::\n",
      "        \n",
      "            with mpl.rc_context(rc={'interactive': False}):\n",
      "                fig, ax = plt.subplots()\n",
      "                ax.plot(range(3), range(3))\n",
      "                fig.savefig('A.png', format='png')\n",
      "                plt.close(fig)\n",
      "    \n",
      "    rcdefaults()\n",
      "        Restore the rc params from Matplotlib's internal defaults.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rc_file_defaults :\n",
      "            Restore the rc params from the rc file originally loaded by Matplotlib.\n",
      "        matplotlib.style.use :\n",
      "            Use a specific style file.  Call ``style.use('default')`` to restore\n",
      "            the default style.\n",
      "    \n",
      "    rgrids(*args, **kwargs)\n",
      "        Get or set the radial gridlines on a polar plot.\n",
      "        \n",
      "        call signatures::\n",
      "        \n",
      "          lines, labels = rgrids()\n",
      "          lines, labels = rgrids(radii, labels=None, angle=22.5, **kwargs)\n",
      "        \n",
      "        When called with no arguments, :func:`rgrid` simply returns the\n",
      "        tuple (*lines*, *labels*), where *lines* is an array of radial\n",
      "        gridlines (:class:`~matplotlib.lines.Line2D` instances) and\n",
      "        *labels* is an array of tick labels\n",
      "        (:class:`~matplotlib.text.Text` instances). When called with\n",
      "        arguments, the labels will appear at the specified radial\n",
      "        distances and angles.\n",
      "        \n",
      "        *labels*, if not *None*, is a len(*radii*) list of strings of the\n",
      "        labels to use at each angle.\n",
      "        \n",
      "        If *labels* is None, the rformatter will be used\n",
      "        \n",
      "        Examples::\n",
      "        \n",
      "          # set the locations of the radial gridlines and labels\n",
      "          lines, labels = rgrids( (0.25, 0.5, 1.0) )\n",
      "        \n",
      "          # set the locations and labels of the radial gridlines and labels\n",
      "          lines, labels = rgrids( (0.25, 0.5, 1.0), ('Tom', 'Dick', 'Harry' )\n",
      "    \n",
      "    savefig(*args, **kwargs)\n",
      "        Save the current figure.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          savefig(fname, dpi=None, facecolor='w', edgecolor='w',\n",
      "                  orientation='portrait', papertype=None, format=None,\n",
      "                  transparent=False, bbox_inches=None, pad_inches=0.1,\n",
      "                  frameon=None)\n",
      "        \n",
      "        The output formats available depend on the backend being used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        fname : str or file-like object\n",
      "            A string containing a path to a filename, or a Python\n",
      "            file-like object, or possibly some backend-dependent object\n",
      "            such as :class:`~matplotlib.backends.backend_pdf.PdfPages`.\n",
      "        \n",
      "            If *format* is *None* and *fname* is a string, the output\n",
      "            format is deduced from the extension of the filename. If\n",
      "            the filename has no extension, the value of the rc parameter\n",
      "            ``savefig.format`` is used.\n",
      "        \n",
      "            If *fname* is not a string, remember to specify *format* to\n",
      "            ensure that the correct backend is used.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        dpi : [ *None* | scalar > 0 | 'figure']\n",
      "            The resolution in dots per inch.  If *None* it will default to\n",
      "            the value ``savefig.dpi`` in the matplotlibrc file. If 'figure'\n",
      "            it will set the dpi to be the value of the figure.\n",
      "        \n",
      "        facecolor : color spec or None, optional\n",
      "            the facecolor of the figure; if None, defaults to savefig.facecolor\n",
      "        \n",
      "        edgecolor : color spec or None, optional\n",
      "            the edgecolor of the figure; if None, defaults to savefig.edgecolor\n",
      "        \n",
      "        orientation : {'landscape', 'portrait'}\n",
      "            not supported on all backends; currently only on postscript output\n",
      "        \n",
      "        papertype : str\n",
      "            One of 'letter', 'legal', 'executive', 'ledger', 'a0' through\n",
      "            'a10', 'b0' through 'b10'. Only supported for postscript\n",
      "            output.\n",
      "        \n",
      "        format : str\n",
      "            One of the file extensions supported by the active\n",
      "            backend.  Most backends support png, pdf, ps, eps and svg.\n",
      "        \n",
      "        transparent : bool\n",
      "            If *True*, the axes patches will all be transparent; the\n",
      "            figure patch will also be transparent unless facecolor\n",
      "            and/or edgecolor are specified via kwargs.\n",
      "            This is useful, for example, for displaying\n",
      "            a plot on top of a colored background on a web page.  The\n",
      "            transparency of these patches will be restored to their\n",
      "            original values upon exit of this function.\n",
      "        \n",
      "        frameon : bool\n",
      "            If *True*, the figure patch will be colored, if *False*, the\n",
      "            figure background will be transparent.  If not provided, the\n",
      "            rcParam 'savefig.frameon' will be used.\n",
      "        \n",
      "        bbox_inches : str or `~matplotlib.transforms.Bbox`, optional\n",
      "            Bbox in inches. Only the given portion of the figure is\n",
      "            saved. If 'tight', try to figure out the tight bbox of\n",
      "            the figure. If None, use savefig.bbox\n",
      "        \n",
      "        pad_inches : scalar, optional\n",
      "            Amount of padding around the figure when bbox_inches is\n",
      "            'tight'. If None, use savefig.pad_inches\n",
      "        \n",
      "        bbox_extra_artists : list of `~matplotlib.artist.Artist`, optional\n",
      "            A list of extra artists that will be considered when the\n",
      "            tight bbox is calculated.\n",
      "    \n",
      "    sca(ax)\n",
      "        Set the current Axes instance to *ax*.\n",
      "        \n",
      "        The current Figure is updated to the parent of *ax*.\n",
      "    \n",
      "    scatter(x, y, s=None, c=None, marker=None, cmap=None, norm=None, vmin=None, vmax=None, alpha=None, linewidths=None, verts=None, edgecolors=None, hold=None, data=None, **kwargs)\n",
      "        Make a scatter plot of `x` vs `y`.\n",
      "        \n",
      "        Marker size is scaled by `s` and marker color is mapped to `c`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : array_like, shape (n, )\n",
      "            Input data\n",
      "        \n",
      "        s : scalar or array_like, shape (n, ), optional\n",
      "            size in points^2.  Default is `rcParams['lines.markersize'] ** 2`.\n",
      "        \n",
      "        c : color, sequence, or sequence of color, optional, default: 'b'\n",
      "            `c` can be a single color format string, or a sequence of color\n",
      "            specifications of length `N`, or a sequence of `N` numbers to be\n",
      "            mapped to colors using the `cmap` and `norm` specified via kwargs\n",
      "            (see below). Note that `c` should not be a single numeric RGB or\n",
      "            RGBA sequence because that is indistinguishable from an array of\n",
      "            values to be colormapped.  `c` can be a 2-D array in which the\n",
      "            rows are RGB or RGBA, however, including the case of a single\n",
      "            row to specify the same color for all points.\n",
      "        \n",
      "        marker : `~matplotlib.markers.MarkerStyle`, optional, default: 'o'\n",
      "            See `~matplotlib.markers` for more information on the different\n",
      "            styles of markers scatter supports. `marker` can be either\n",
      "            an instance of the class or the text shorthand for a particular\n",
      "            marker.\n",
      "        \n",
      "        cmap : `~matplotlib.colors.Colormap`, optional, default: None\n",
      "            A `~matplotlib.colors.Colormap` instance or registered name.\n",
      "            `cmap` is only used if `c` is an array of floats. If None,\n",
      "            defaults to rc `image.cmap`.\n",
      "        \n",
      "        norm : `~matplotlib.colors.Normalize`, optional, default: None\n",
      "            A `~matplotlib.colors.Normalize` instance is used to scale\n",
      "            luminance data to 0, 1. `norm` is only used if `c` is an array of\n",
      "            floats. If `None`, use the default :func:`normalize`.\n",
      "        \n",
      "        vmin, vmax : scalar, optional, default: None\n",
      "            `vmin` and `vmax` are used in conjunction with `norm` to normalize\n",
      "            luminance data.  If either are `None`, the min and max of the\n",
      "            color array is used.  Note if you pass a `norm` instance, your\n",
      "            settings for `vmin` and `vmax` will be ignored.\n",
      "        \n",
      "        alpha : scalar, optional, default: None\n",
      "            The alpha blending value, between 0 (transparent) and 1 (opaque)\n",
      "        \n",
      "        linewidths : scalar or array_like, optional, default: None\n",
      "            If None, defaults to (lines.linewidth,).\n",
      "        \n",
      "        verts : sequence of (x, y), optional\n",
      "            If `marker` is None, these vertices will be used to\n",
      "            construct the marker.  The center of the marker is located\n",
      "            at (0,0) in normalized units.  The overall marker is rescaled\n",
      "            by ``s``.\n",
      "        \n",
      "        edgecolors : color or sequence of color, optional, default: None\n",
      "            If None, defaults to 'face'\n",
      "        \n",
      "            If 'face', the edge color will always be the same as\n",
      "            the face color.\n",
      "        \n",
      "            If it is 'none', the patch boundary will not\n",
      "            be drawn.\n",
      "        \n",
      "            For non-filled markers, the `edgecolors` kwarg\n",
      "            is ignored and forced to 'face' internally.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        paths : `~matplotlib.collections.PathCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.collections.Collection` properties\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        plot : to plot scatter plots when markers are identical in size and\n",
      "            color\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \n",
      "        * The `plot` function will be faster for scatterplots where markers\n",
      "          don't vary in size or color.\n",
      "        \n",
      "        * Any or all of `x`, `y`, `s`, and `c` may be masked arrays, in which\n",
      "          case all masks will be combined and only unmasked points will be\n",
      "          plotted.\n",
      "        \n",
      "          Fundamentally, scatter works with 1-D arrays; `x`, `y`, `s`, and `c`\n",
      "          may be input as 2-D arrays, but within scatter they will be\n",
      "          flattened. The exception is `c`, which will be flattened only if its\n",
      "          size matches the size of `x` and `y`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'c', 'color', 'edgecolors', 'facecolor', 'facecolors', 'linewidths', 's', 'x', 'y'.\n",
      "    \n",
      "    sci(im)\n",
      "        Set the current image.  This image will be the target of colormap\n",
      "        commands like :func:`~matplotlib.pyplot.jet`,\n",
      "        :func:`~matplotlib.pyplot.hot` or\n",
      "        :func:`~matplotlib.pyplot.clim`).  The current image is an\n",
      "        attribute of the current axes.\n",
      "    \n",
      "    semilogx(*args, **kwargs)\n",
      "        Make a plot with log scaling on the *x* axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        basex : float, optional\n",
      "            Base of the *x* logarithm. The scalar should be larger\n",
      "            than 1.\n",
      "        \n",
      "        subsx : array_like, optional\n",
      "            The location of the minor xticks; *None* defaults to\n",
      "            autosubs, which depend on the number of decades in the\n",
      "            plot; see :meth:`~matplotlib.axes.Axes.set_xscale` for\n",
      "            details.\n",
      "        \n",
      "        nonposx : string, optional, {'mask', 'clip'}\n",
      "            Non-positive values in *x* can be masked as\n",
      "            invalid, or clipped to a very small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.pyplot.plot`\n",
      "            Log-scaled plot on the *x* axis.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function supports all the keyword arguments of\n",
      "        :func:`~matplotlib.pyplot.plot` and\n",
      "        :meth:`matplotlib.axes.Axes.set_xscale`.\n",
      "    \n",
      "    semilogy(*args, **kwargs)\n",
      "        Make a plot with log scaling on the *y* axis.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        basey : float, optional\n",
      "            Base of the *y* logarithm. The scalar should be larger\n",
      "            than 1.\n",
      "        \n",
      "        subsy : array_like, optional\n",
      "            The location of the minor yticks; *None* defaults to\n",
      "            autosubs, which depend on the number of decades in the\n",
      "            plot; see :meth:`~matplotlib.axes.Axes.set_yscale` for\n",
      "            details.\n",
      "        \n",
      "        nonposy : string, optional, {'mask', 'clip'}\n",
      "            Non-positive values in *y* can be masked as\n",
      "            invalid, or clipped to a very small positive number.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `~matplotlib.pyplot.plot`\n",
      "            Log-scaled plot on the *y* axis.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs :\n",
      "            Keyword arguments control the :class:`~matplotlib.lines.Line2D`\n",
      "            properties:\n",
      "        \n",
      "              agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          antialiased or aa: [True | False] \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          color or c: any matplotlib color \n",
      "          contains: a callable function \n",
      "          dash_capstyle: ['butt' | 'round' | 'projecting'] \n",
      "          dash_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          dashes: sequence of on/off ink in points \n",
      "          drawstyle: ['default' | 'steps' | 'steps-pre' | 'steps-mid' | 'steps-post'] \n",
      "          figure: a `~.Figure` instance \n",
      "          fillstyle: ['full' | 'left' | 'right' | 'bottom' | 'top' | 'none'] \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          linestyle or ls: ['solid' | 'dashed', 'dashdot', 'dotted' | (offset, on-off-dash-seq) | ``'-'`` | ``'--'`` | ``'-.'`` | ``':'`` | ``'None'`` | ``' '`` | ``''``]\n",
      "          linewidth or lw: float value in points \n",
      "          marker: :mod:`A valid marker style <matplotlib.markers>`\n",
      "          markeredgecolor or mec: any matplotlib color \n",
      "          markeredgewidth or mew: float value in points \n",
      "          markerfacecolor or mfc: any matplotlib color \n",
      "          markerfacecoloralt or mfcalt: any matplotlib color \n",
      "          markersize or ms: float \n",
      "          markevery: [None | int | length-2 tuple of int | slice | list/array of int | float | length-2 tuple of float]\n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: float distance in points or callable pick function ``fn(artist, event)`` \n",
      "          pickradius: float distance in points\n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          solid_capstyle: ['butt' | 'round' |  'projecting'] \n",
      "          solid_joinstyle: ['miter' | 'round' | 'bevel'] \n",
      "          transform: a :class:`matplotlib.transforms.Transform` instance \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          xdata: 1D array \n",
      "          ydata: 1D array \n",
      "          zorder: float \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function supports all the keyword arguments of\n",
      "        :func:`~matplotlib.pyplot.plot` and\n",
      "        :meth:`matplotlib.axes.Axes.set_yscale`.\n",
      "    \n",
      "    set_cmap(cmap)\n",
      "        Set the default colormap.  Applies to the current image if any.\n",
      "        See help(colormaps) for more information.\n",
      "        \n",
      "        *cmap* must be a :class:`~matplotlib.colors.Colormap` instance, or\n",
      "        the name of a registered colormap.\n",
      "        \n",
      "        See :func:`matplotlib.cm.register_cmap` and\n",
      "        :func:`matplotlib.cm.get_cmap`.\n",
      "    \n",
      "    setp(*args, **kwargs)\n",
      "        Set a property on an artist object.\n",
      "        \n",
      "        matplotlib supports the use of :func:`setp` (\"set property\") and\n",
      "        :func:`getp` to set and get object properties, as well as to do\n",
      "        introspection on the object.  For example, to set the linestyle of a\n",
      "        line to be dashed, you can do::\n",
      "        \n",
      "          >>> line, = plot([1,2,3])\n",
      "          >>> setp(line, linestyle='--')\n",
      "        \n",
      "        If you want to know the valid types of arguments, you can provide\n",
      "        the name of the property you want to set without a value::\n",
      "        \n",
      "          >>> setp(line, 'linestyle')\n",
      "              linestyle: [ '-' | '--' | '-.' | ':' | 'steps' | 'None' ]\n",
      "        \n",
      "        If you want to see all the properties that can be set, and their\n",
      "        possible values, you can do::\n",
      "        \n",
      "          >>> setp(line)\n",
      "              ... long output listing omitted\n",
      "        \n",
      "        You may specify another output file to `setp` if `sys.stdout` is not\n",
      "        acceptable for some reason using the `file` keyword-only argument::\n",
      "        \n",
      "          >>> with fopen('output.log') as f:\n",
      "          >>>     setp(line, file=f)\n",
      "        \n",
      "        :func:`setp` operates on a single instance or a iterable of\n",
      "        instances. If you are in query mode introspecting the possible\n",
      "        values, only the first instance in the sequence is used. When\n",
      "        actually setting values, all the instances will be set.  e.g.,\n",
      "        suppose you have a list of two lines, the following will make both\n",
      "        lines thicker and red::\n",
      "        \n",
      "          >>> x = arange(0,1.0,0.01)\n",
      "          >>> y1 = sin(2*pi*x)\n",
      "          >>> y2 = sin(4*pi*x)\n",
      "          >>> lines = plot(x, y1, x, y2)\n",
      "          >>> setp(lines, linewidth=2, color='r')\n",
      "        \n",
      "        :func:`setp` works with the MATLAB style string/value pairs or\n",
      "        with python kwargs.  For example, the following are equivalent::\n",
      "        \n",
      "          >>> setp(lines, 'linewidth', 2, 'color', 'r')  # MATLAB style\n",
      "          >>> setp(lines, linewidth=2, color='r')        # python style\n",
      "    \n",
      "    show(*args, **kw)\n",
      "        Display a figure.\n",
      "        When running in ipython with its pylab mode, display all\n",
      "        figures and return to the ipython prompt.\n",
      "        \n",
      "        In non-interactive mode, display all figures and block until\n",
      "        the figures have been closed; in interactive mode it has no\n",
      "        effect unless figures were created prior to a change from\n",
      "        non-interactive to interactive mode (not recommended).  In\n",
      "        that case it displays the figures but does not block.\n",
      "        \n",
      "        A single experimental keyword argument, *block*, may be\n",
      "        set to True or False to override the blocking behavior\n",
      "        described above.\n",
      "    \n",
      "    specgram(x, NFFT=None, Fs=None, Fc=None, detrend=None, window=None, noverlap=None, cmap=None, xextent=None, pad_to=None, sides=None, scale_by_freq=None, mode=None, scale=None, vmin=None, vmax=None, hold=None, data=None, **kwargs)\n",
      "        Plot a spectrogram.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          specgram(x, NFFT=256, Fs=2, Fc=0, detrend=mlab.detrend_none,\n",
      "                   window=mlab.window_hanning, noverlap=128,\n",
      "                   cmap=None, xextent=None, pad_to=None, sides='default',\n",
      "                   scale_by_freq=None, mode='default', scale='default',\n",
      "                   **kwargs)\n",
      "        \n",
      "        Compute and plot a spectrogram of data in *x*.  Data are split into\n",
      "        *NFFT* length segments and the spectrum of each section is\n",
      "        computed.  The windowing function *window* is applied to each\n",
      "        segment, and the amount of overlap of each segment is\n",
      "        specified with *noverlap*. The spectrogram is plotted as a colormap\n",
      "        (using imshow).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : 1-D array or sequence\n",
      "            Array or sequence containing the data.\n",
      "        \n",
      "        Fs : scalar\n",
      "            The sampling frequency (samples per time unit).  It is used\n",
      "            to calculate the Fourier frequencies, freqs, in cycles per time\n",
      "            unit. The default value is 2.\n",
      "        \n",
      "        window : callable or ndarray\n",
      "            A function or a vector of length *NFFT*. To create window\n",
      "            vectors see :func:`window_hanning`, :func:`window_none`,\n",
      "            :func:`numpy.blackman`, :func:`numpy.hamming`,\n",
      "            :func:`numpy.bartlett`, :func:`scipy.signal`,\n",
      "            :func:`scipy.signal.get_window`, etc. The default is\n",
      "            :func:`window_hanning`.  If a function is passed as the\n",
      "            argument, it must take a data segment as an argument and\n",
      "            return the windowed version of the segment.\n",
      "        \n",
      "        sides : [ 'default' | 'onesided' | 'twosided' ]\n",
      "            Specifies which sides of the spectrum to return.  Default gives the\n",
      "            default behavior, which returns one-sided for real data and both\n",
      "            for complex data.  'onesided' forces the return of a one-sided\n",
      "            spectrum, while 'twosided' forces two-sided.\n",
      "        \n",
      "        pad_to : integer\n",
      "            The number of points to which the data segment is padded when\n",
      "            performing the FFT.  This can be different from *NFFT*, which\n",
      "            specifies the number of data points used.  While not increasing\n",
      "            the actual resolution of the spectrum (the minimum distance between\n",
      "            resolvable peaks), this can give more points in the plot,\n",
      "            allowing for more detail. This corresponds to the *n* parameter\n",
      "            in the call to fft(). The default is None, which sets *pad_to*\n",
      "            equal to *NFFT*\n",
      "        \n",
      "        NFFT : integer\n",
      "            The number of data points used in each block for the FFT.\n",
      "            A power 2 is most efficient.  The default value is 256.\n",
      "            This should *NOT* be used to get zero padding, or the scaling of the\n",
      "            result will be incorrect. Use *pad_to* for this instead.\n",
      "        \n",
      "        detrend : {'default', 'constant', 'mean', 'linear', 'none'} or callable\n",
      "            The function applied to each segment before fft-ing,\n",
      "            designed to remove the mean or linear trend.  Unlike in\n",
      "            MATLAB, where the *detrend* parameter is a vector, in\n",
      "            matplotlib is it a function.  The :mod:`~matplotlib.pylab`\n",
      "            module defines :func:`~matplotlib.pylab.detrend_none`,\n",
      "            :func:`~matplotlib.pylab.detrend_mean`, and\n",
      "            :func:`~matplotlib.pylab.detrend_linear`, but you can use\n",
      "            a custom function as well.  You can also use a string to choose\n",
      "            one of the functions.  'default', 'constant', and 'mean' call\n",
      "            :func:`~matplotlib.pylab.detrend_mean`.  'linear' calls\n",
      "            :func:`~matplotlib.pylab.detrend_linear`.  'none' calls\n",
      "            :func:`~matplotlib.pylab.detrend_none`.\n",
      "        \n",
      "        scale_by_freq : boolean, optional\n",
      "            Specifies whether the resulting density values should be scaled\n",
      "            by the scaling frequency, which gives density in units of Hz^-1.\n",
      "            This allows for integration over the returned frequency values.\n",
      "            The default is True for MATLAB compatibility.\n",
      "        \n",
      "        mode : [ 'default' | 'psd' | 'magnitude' | 'angle' | 'phase' ]\n",
      "            What sort of spectrum to use.  Default is 'psd', which takes\n",
      "            the power spectral density.  'complex' returns the complex-valued\n",
      "            frequency spectrum.  'magnitude' returns the magnitude spectrum.\n",
      "            'angle' returns the phase spectrum without unwrapping.  'phase'\n",
      "            returns the phase spectrum with unwrapping.\n",
      "        \n",
      "        noverlap : integer\n",
      "            The number of points of overlap between blocks.  The\n",
      "            default value is 128.\n",
      "        \n",
      "        scale : [ 'default' | 'linear' | 'dB' ]\n",
      "            The scaling of the values in the *spec*.  'linear' is no scaling.\n",
      "            'dB' returns the values in dB scale.  When *mode* is 'psd',\n",
      "            this is dB power (10 * log10).  Otherwise this is dB amplitude\n",
      "            (20 * log10). 'default' is 'dB' if *mode* is 'psd' or\n",
      "            'magnitude' and 'linear' otherwise.  This must be 'linear'\n",
      "            if *mode* is 'angle' or 'phase'.\n",
      "        \n",
      "        Fc : integer\n",
      "            The center frequency of *x* (defaults to 0), which offsets\n",
      "            the x extents of the plot to reflect the frequency range used\n",
      "            when a signal is acquired and then filtered and downsampled to\n",
      "            baseband.\n",
      "        \n",
      "        cmap :\n",
      "            A :class:`matplotlib.colors.Colormap` instance; if *None*, use\n",
      "            default determined by rc\n",
      "        \n",
      "        xextent : [None | (xmin, xmax)]\n",
      "            The image extent along the x-axis. The default sets *xmin* to the\n",
      "            left border of the first bin (*spectrum* column) and *xmax* to the\n",
      "            right border of the last bin. Note that for *noverlap>0* the width\n",
      "            of the bins is smaller than those of the segments.\n",
      "        \n",
      "        **kwargs :\n",
      "            Additional kwargs are passed on to imshow which makes the\n",
      "            specgram image\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "            *detrend* and *scale_by_freq* only apply when *mode* is set to\n",
      "            'psd'\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        spectrum : 2-D array\n",
      "            Columns are the periodograms of successive segments.\n",
      "        \n",
      "        freqs : 1-D array\n",
      "            The frequencies corresponding to the rows in *spectrum*.\n",
      "        \n",
      "        t : 1-D array\n",
      "            The times corresponding to midpoints of segments (i.e., the columns\n",
      "            in *spectrum*).\n",
      "        \n",
      "        im : instance of class :class:`~matplotlib.image.AxesImage`\n",
      "            The image created by imshow containing the spectrogram\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        :func:`psd`\n",
      "            :func:`psd` differs in the default overlap; in returning the mean\n",
      "            of the segment periodograms; in not returning times; and in\n",
      "            generating a line plot instead of colormap.\n",
      "        \n",
      "        :func:`magnitude_spectrum`\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'magnitude'. Plots a line instead of a colormap.\n",
      "        \n",
      "        :func:`angle_spectrum`\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'angle'. Plots a line instead of a colormap.\n",
      "        \n",
      "        :func:`phase_spectrum`\n",
      "            A single spectrum, similar to having a single segment when *mode*\n",
      "            is 'phase'. Plots a line instead of a colormap.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x'.\n",
      "    \n",
      "    spectral()\n",
      "        set the default colormap to spectral and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    spring()\n",
      "        set the default colormap to spring and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    spy(Z, precision=0, marker=None, markersize=None, aspect='equal', **kwargs)\n",
      "        Plot the sparsity pattern on a 2-D array.\n",
      "        \n",
      "        ``spy(Z)`` plots the sparsity pattern of the 2-D array *Z*.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        Z : sparse array (n, m)\n",
      "            The array to be plotted.\n",
      "        \n",
      "        precision : float, optional, default: 0\n",
      "            If *precision* is 0, any non-zero value will be plotted; else,\n",
      "            values of :math:`|Z| > precision` will be plotted.\n",
      "        \n",
      "            For :class:`scipy.sparse.spmatrix` instances, there is a special\n",
      "            case: if *precision* is 'present', any value present in the array\n",
      "            will be plotted, even if it is identically zero.\n",
      "        \n",
      "        origin : [\"upper\", \"lower\"], optional, default: \"upper\"\n",
      "            Place the [0,0] index of the array in the upper left or lower left\n",
      "            corner of the axes.\n",
      "        \n",
      "        aspect : ['auto' | 'equal' | scalar], optional, default: \"equal\"\n",
      "        \n",
      "            If 'equal', and `extent` is None, changes the axes aspect ratio to\n",
      "            match that of the image. If `extent` is not `None`, the axes\n",
      "            aspect ratio is changed to match that of the extent.\n",
      "        \n",
      "        \n",
      "            If 'auto', changes the image aspect ratio to match that of the\n",
      "            axes.\n",
      "        \n",
      "            If None, default to rc ``image.aspect`` value.\n",
      "        \n",
      "        Two plotting styles are available: image or marker. Both\n",
      "        are available for full arrays, but only the marker style\n",
      "        works for :class:`scipy.sparse.spmatrix` instances.\n",
      "        \n",
      "        If *marker* and *markersize* are *None*, an image will be\n",
      "        returned and any remaining kwargs are passed to\n",
      "        :func:`~matplotlib.pyplot.imshow`; else, a\n",
      "        :class:`~matplotlib.lines.Line2D` object will be returned with\n",
      "        the value of marker determining the marker type, and any\n",
      "        remaining kwargs passed to the\n",
      "        :meth:`~matplotlib.axes.Axes.plot` method.\n",
      "        \n",
      "        If *marker* and *markersize* are *None*, useful kwargs include:\n",
      "        \n",
      "        * *cmap*\n",
      "        * *alpha*\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        imshow : for image options.\n",
      "        plot : for plotting options\n",
      "    \n",
      "    stackplot(x, *args, **kwargs)\n",
      "        Draws a stacked area plot.\n",
      "        \n",
      "        *x* : 1d array of dimension N\n",
      "        \n",
      "        *y* : 2d array of dimension MxN, OR any number 1d arrays each of dimension\n",
      "              1xN. The data is assumed to be unstacked. Each of the following\n",
      "              calls is legal::\n",
      "        \n",
      "                stackplot(x, y)               # where y is MxN\n",
      "                stackplot(x, y1, y2, y3, y4)  # where y1, y2, y3, y4, are all 1xNm\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "        *baseline* : ['zero', 'sym', 'wiggle', 'weighted_wiggle']\n",
      "                    Method used to calculate the baseline. 'zero' is just a\n",
      "                    simple stacked plot. 'sym' is symmetric around zero and\n",
      "                    is sometimes called `ThemeRiver`.  'wiggle' minimizes the\n",
      "                    sum of the squared slopes. 'weighted_wiggle' does the\n",
      "                    same but weights to account for size of each layer.\n",
      "                    It is also called `Streamgraph`-layout. More details\n",
      "                    can be found at http://leebyron.com/streamgraph/.\n",
      "        \n",
      "        \n",
      "        *labels* : A list or tuple of labels to assign to each data series.\n",
      "        \n",
      "        \n",
      "        *colors* : A list or tuple of colors. These will be cycled through and\n",
      "                   used to colour the stacked areas.\n",
      "                   All other keyword arguments are passed to\n",
      "                   :func:`~matplotlib.Axes.fill_between`\n",
      "        \n",
      "        Returns *r* : A list of\n",
      "        :class:`~matplotlib.collections.PolyCollection`, one for each\n",
      "        element in the stacked area plot.\n",
      "    \n",
      "    stem(*args, **kwargs)\n",
      "        Create a stem plot.\n",
      "        \n",
      "        Call signatures::\n",
      "        \n",
      "          stem(y, linefmt='b-', markerfmt='bo', basefmt='r-')\n",
      "          stem(x, y, linefmt='b-', markerfmt='bo', basefmt='r-')\n",
      "        \n",
      "        A stem plot plots vertical lines (using *linefmt*) at each *x*\n",
      "        location from the baseline to *y*, and places a marker there\n",
      "        using *markerfmt*.  A horizontal line at 0 is plotted using\n",
      "        *basefmt*.\n",
      "        \n",
      "        If no *x* values are provided, the default is (0, 1, ..., len(y) - 1)\n",
      "        \n",
      "        Return value is a tuple (*markerline*, *stemlines*,\n",
      "        *baseline*). See :class:`~matplotlib.container.StemContainer`\n",
      "        \n",
      "        .. seealso::\n",
      "            This\n",
      "            `document <http://www.mathworks.com/help/techdoc/ref/stem.html>`_\n",
      "            for details.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All positional and all keyword arguments.\n",
      "    \n",
      "    step(x, y, *args, **kwargs)\n",
      "        Make a step plot.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D sequence, and it is assumed, but not checked,\n",
      "            that it is uniformly increasing.\n",
      "        \n",
      "        y : array_like\n",
      "            1-D sequence\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        list\n",
      "            List of lines that were added.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        where : [ 'pre' | 'post' | 'mid'  ]\n",
      "            If 'pre' (the default), the interval from\n",
      "            ``x[i]`` to ``x[i+1]`` has level ``y[i+1]``.\n",
      "        \n",
      "            If 'post', that interval has level ``y[i]``.\n",
      "        \n",
      "            If 'mid', the jumps in *y* occur half-way between the\n",
      "            *x*-values.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Additional parameters are the same as those for\n",
      "        :func:`~matplotlib.pyplot.plot`.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    streamplot(x, y, u, v, density=1, linewidth=None, color=None, cmap=None, norm=None, arrowsize=1, arrowstyle='-|>', minlength=0.1, transform=None, zorder=None, start_points=None, maxlength=4.0, integration_direction='both', hold=None, data=None)\n",
      "        Draws streamlines of a vector flow.\n",
      "        \n",
      "        *x*, *y* : 1d arrays\n",
      "            an *evenly spaced* grid.\n",
      "        *u*, *v* : 2d arrays\n",
      "            x and y-velocities. Number of rows should match length of y, and\n",
      "            the number of columns should match x.\n",
      "        *density* : float or 2-tuple\n",
      "            Controls the closeness of streamlines. When `density = 1`, the domain\n",
      "            is divided into a 30x30 grid---*density* linearly scales this grid.\n",
      "            Each cell in the grid can have, at most, one traversing streamline.\n",
      "            For different densities in each direction, use [density_x, density_y].\n",
      "        *linewidth* : numeric or 2d array\n",
      "            vary linewidth when given a 2d array with the same shape as velocities.\n",
      "        *color* : matplotlib color code, or 2d array\n",
      "            Streamline color. When given an array with the same shape as\n",
      "            velocities, *color* values are converted to colors using *cmap*.\n",
      "        *cmap* : :class:`~matplotlib.colors.Colormap`\n",
      "            Colormap used to plot streamlines and arrows. Only necessary when using\n",
      "            an array input for *color*.\n",
      "        *norm* : :class:`~matplotlib.colors.Normalize`\n",
      "            Normalize object used to scale luminance data to 0, 1. If None, stretch\n",
      "            (min, max) to (0, 1). Only necessary when *color* is an array.\n",
      "        *arrowsize* : float\n",
      "            Factor scale arrow size.\n",
      "        *arrowstyle* : str\n",
      "            Arrow style specification.\n",
      "            See :class:`~matplotlib.patches.FancyArrowPatch`.\n",
      "        *minlength* : float\n",
      "            Minimum length of streamline in axes coordinates.\n",
      "        *start_points*: Nx2 array\n",
      "            Coordinates of starting points for the streamlines.\n",
      "            In data coordinates, the same as the ``x`` and ``y`` arrays.\n",
      "        *zorder* : int\n",
      "            any number\n",
      "        *maxlength* : float\n",
      "            Maximum length of streamline in axes coordinates.\n",
      "        *integration_direction* : ['forward', 'backward', 'both']\n",
      "            Integrate the streamline in forward, backward or both directions.\n",
      "        \n",
      "        Returns:\n",
      "        \n",
      "            *stream_container* : StreamplotSet\n",
      "                Container object with attributes\n",
      "        \n",
      "                    - lines: `matplotlib.collections.LineCollection` of streamlines\n",
      "        \n",
      "                    - arrows: collection of `matplotlib.patches.FancyArrowPatch`\n",
      "                      objects representing arrows half-way along stream\n",
      "                      lines.\n",
      "        \n",
      "                This container will probably change in the future to allow changes\n",
      "                to the colormap, alpha, etc. for both lines and arrows, but these\n",
      "                changes should be backward compatible.\n",
      "    \n",
      "    subplot(*args, **kwargs)\n",
      "        Return a subplot axes at the given grid position.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "           subplot(nrows, ncols, index, **kwargs)\n",
      "        \n",
      "        In the current figure, create and return an `~.Axes`, at position *index*\n",
      "        of a (virtual) grid of *nrows* by *ncols* axes.  Indexes go from 1 to\n",
      "        ``nrows * ncols``, incrementing in row-major order.\n",
      "        \n",
      "        If *nrows*, *ncols* and *index* are all less than 10, they can also be\n",
      "        given as a single, concatenated, three-digit number.\n",
      "        \n",
      "        For example, ``subplot(2, 3, 3)`` and ``subplot(233)`` both create an\n",
      "        `~.Axes` at the top right corner of the current figure, occupying half of\n",
      "        the figure height and a third of the figure width.\n",
      "        \n",
      "        .. note::\n",
      "        \n",
      "           Creating a subplot will delete any pre-existing subplot that overlaps\n",
      "           with it beyond sharing a boundary::\n",
      "        \n",
      "              import matplotlib.pyplot as plt\n",
      "              # plot a line, implicitly creating a subplot(111)\n",
      "              plt.plot([1,2,3])\n",
      "              # now create a subplot which represents the top plot of a grid\n",
      "              # with 2 rows and 1 column. Since this subplot will overlap the\n",
      "              # first, the plot (and its axes) previously created, will be removed\n",
      "              plt.subplot(211)\n",
      "              plt.plot(range(12))\n",
      "              plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background\n",
      "        \n",
      "           If you do not want this behavior, use the\n",
      "           :meth:`~matplotlib.figure.Figure.add_subplot` method or the\n",
      "           :func:`~matplotlib.pyplot.axes` function instead.\n",
      "        \n",
      "        Keyword arguments:\n",
      "        \n",
      "          *facecolor*:\n",
      "            The background color of the subplot, which can be any valid\n",
      "            color specifier.  See :mod:`matplotlib.colors` for more\n",
      "            information.\n",
      "        \n",
      "          *polar*:\n",
      "            A boolean flag indicating whether the subplot plot should be\n",
      "            a polar projection.  Defaults to *False*.\n",
      "        \n",
      "          *projection*:\n",
      "            A string giving the name of a custom projection to be used\n",
      "            for the subplot. This projection must have been previously\n",
      "            registered. See :mod:`matplotlib.projections`.\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`~matplotlib.pyplot.axes`\n",
      "                For additional information on :func:`axes` and\n",
      "                :func:`subplot` keyword arguments.\n",
      "        \n",
      "            :file:`gallery/pie_and_polar_charts/polar_scatter.py`\n",
      "                For an example\n",
      "        \n",
      "        **Example:**\n",
      "        \n",
      "        .. plot:: gallery/subplots_axes_and_figures/subplot.py\n",
      "    \n",
      "    subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs)\n",
      "        Create an axis at specific location inside a regular grid.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        shape : sequence of 2 ints\n",
      "            Shape of grid in which to place axis.\n",
      "            First entry is number of rows, second entry is number of columns.\n",
      "        \n",
      "        loc : sequence of 2 ints\n",
      "            Location to place axis within grid.\n",
      "            First entry is row number, second entry is column number.\n",
      "        \n",
      "        rowspan : int\n",
      "            Number of rows for the axis to span to the right.\n",
      "        \n",
      "        colspan : int\n",
      "            Number of columns for the axis to span downwards.\n",
      "        \n",
      "        fig : `Figure`, optional\n",
      "            Figure to place axis in. Defaults to current figure.\n",
      "        \n",
      "        **kwargs\n",
      "            Additional keyword arguments are handed to `add_subplot`.\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The following call ::\n",
      "        \n",
      "            subplot2grid(shape, loc, rowspan=1, colspan=1)\n",
      "        \n",
      "        is identical to ::\n",
      "        \n",
      "            gridspec=GridSpec(shape[0], shape[1])\n",
      "            subplotspec=gridspec.new_subplotspec(loc, rowspan, colspan)\n",
      "            subplot(subplotspec)\n",
      "    \n",
      "    subplot_tool(targetfig=None)\n",
      "        Launch a subplot tool window for a figure.\n",
      "        \n",
      "        A :class:`matplotlib.widgets.SubplotTool` instance is returned.\n",
      "    \n",
      "    subplots(nrows=1, ncols=1, sharex=False, sharey=False, squeeze=True, subplot_kw=None, gridspec_kw=None, **fig_kw)\n",
      "        Create a figure and a set of subplots\n",
      "        \n",
      "        This utility wrapper makes it convenient to create common layouts of\n",
      "        subplots, including the enclosing figure object, in a single call.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        nrows, ncols : int, optional, default: 1\n",
      "            Number of rows/columns of the subplot grid.\n",
      "        \n",
      "        sharex, sharey : bool or {'none', 'all', 'row', 'col'}, default: False\n",
      "            Controls sharing of properties among x (`sharex`) or y (`sharey`)\n",
      "            axes:\n",
      "        \n",
      "                - True or 'all': x- or y-axis will be shared among all\n",
      "                  subplots.\n",
      "                - False or 'none': each subplot x- or y-axis will be\n",
      "                  independent.\n",
      "                - 'row': each subplot row will share an x- or y-axis.\n",
      "                - 'col': each subplot column will share an x- or y-axis.\n",
      "        \n",
      "            When subplots have a shared x-axis along a column, only the x tick\n",
      "            labels of the bottom subplot are visible.  Similarly, when subplots\n",
      "            have a shared y-axis along a row, only the y tick labels of the first\n",
      "            column subplot are visible.\n",
      "        \n",
      "        squeeze : bool, optional, default: True\n",
      "            - If True, extra dimensions are squeezed out from the returned Axes\n",
      "              object:\n",
      "        \n",
      "                - if only one subplot is constructed (nrows=ncols=1), the\n",
      "                  resulting single Axes object is returned as a scalar.\n",
      "                - for Nx1 or 1xN subplots, the returned object is a 1D numpy\n",
      "                  object array of Axes objects are returned as numpy 1D arrays.\n",
      "                - for NxM, subplots with N>1 and M>1 are returned as a 2D arrays.\n",
      "        \n",
      "            - If False, no squeezing at all is done: the returned Axes object is\n",
      "              always a 2D array containing Axes instances, even if it ends up\n",
      "              being 1x1.\n",
      "        \n",
      "        subplot_kw : dict, optional\n",
      "            Dict with keywords passed to the\n",
      "            :meth:`~matplotlib.figure.Figure.add_subplot` call used to create each\n",
      "            subplot.\n",
      "        \n",
      "        gridspec_kw : dict, optional\n",
      "            Dict with keywords passed to the\n",
      "            :class:`~matplotlib.gridspec.GridSpec` constructor used to create the\n",
      "            grid the subplots are placed on.\n",
      "        \n",
      "        **fig_kw :\n",
      "            All additional keyword arguments are passed to the :func:`figure` call.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        fig : :class:`matplotlib.figure.Figure` object\n",
      "        \n",
      "        ax : Axes object or array of Axes objects.\n",
      "        \n",
      "            ax can be either a single :class:`matplotlib.axes.Axes` object or an\n",
      "            array of Axes objects if more than one subplot was created.  The\n",
      "            dimensions of the resulting array can be controlled with the squeeze\n",
      "            keyword, see above.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        First create some toy data:\n",
      "        \n",
      "        >>> x = np.linspace(0, 2*np.pi, 400)\n",
      "        >>> y = np.sin(x**2)\n",
      "        \n",
      "        Creates just a figure and only one subplot\n",
      "        \n",
      "        >>> fig, ax = plt.subplots()\n",
      "        >>> ax.plot(x, y)\n",
      "        >>> ax.set_title('Simple plot')\n",
      "        \n",
      "        Creates two subplots and unpacks the output array immediately\n",
      "        \n",
      "        >>> f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
      "        >>> ax1.plot(x, y)\n",
      "        >>> ax1.set_title('Sharing Y axis')\n",
      "        >>> ax2.scatter(x, y)\n",
      "        \n",
      "        Creates four polar axes, and accesses them through the returned array\n",
      "        \n",
      "        >>> fig, axes = plt.subplots(2, 2, subplot_kw=dict(polar=True))\n",
      "        >>> axes[0, 0].plot(x, y)\n",
      "        >>> axes[1, 1].scatter(x, y)\n",
      "        \n",
      "        Share a X axis with each column of subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex='col')\n",
      "        \n",
      "        Share a Y axis with each row of subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharey='row')\n",
      "        \n",
      "        Share both X and Y axes with all subplots\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex='all', sharey='all')\n",
      "        \n",
      "        Note that this is the same as\n",
      "        \n",
      "        >>> plt.subplots(2, 2, sharex=True, sharey=True)\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        figure\n",
      "        subplot\n",
      "    \n",
      "    subplots_adjust(*args, **kwargs)\n",
      "        Tune the subplot layout.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          subplots_adjust(left=None, bottom=None, right=None, top=None,\n",
      "                          wspace=None, hspace=None)\n",
      "        \n",
      "        The parameter meanings (and suggested defaults) are::\n",
      "        \n",
      "          left  = 0.125  # the left side of the subplots of the figure\n",
      "          right = 0.9    # the right side of the subplots of the figure\n",
      "          bottom = 0.1   # the bottom of the subplots of the figure\n",
      "          top = 0.9      # the top of the subplots of the figure\n",
      "          wspace = 0.2   # the amount of width reserved for blank space between subplots,\n",
      "                         # expressed as a fraction of the average axis width\n",
      "          hspace = 0.2   # the amount of height reserved for white space between subplots,\n",
      "                         # expressed as a fraction of the average axis height\n",
      "        \n",
      "        The actual defaults are controlled by the rc file\n",
      "    \n",
      "    summer()\n",
      "        set the default colormap to summer and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    suptitle(*args, **kwargs)\n",
      "        Add a centered title to the figure.\n",
      "        \n",
      "        kwargs are :class:`matplotlib.text.Text` properties.  Using figure\n",
      "        coordinates, the defaults are:\n",
      "        \n",
      "          x : 0.5\n",
      "            The x location of the text in figure coords\n",
      "        \n",
      "          y : 0.98\n",
      "            The y location of the text in figure coords\n",
      "        \n",
      "          horizontalalignment : 'center'\n",
      "            The horizontal alignment of the text\n",
      "        \n",
      "          verticalalignment : 'top'\n",
      "            The vertical alignment of the text\n",
      "        \n",
      "        If the `fontproperties` keyword argument is given then the\n",
      "        rcParams defaults for `fontsize` (`figure.titlesize`) and\n",
      "        `fontweight` (`figure.titleweight`) will be ignored in favour\n",
      "        of the `FontProperties` defaults.\n",
      "        \n",
      "        A :class:`matplotlib.text.Text` instance is returned.\n",
      "        \n",
      "        Example::\n",
      "        \n",
      "          fig.suptitle('this is the figure title', fontsize=12)\n",
      "    \n",
      "    switch_backend(newbackend)\n",
      "        Switch the default backend.  This feature is **experimental**, and\n",
      "        is only expected to work switching to an image backend.  e.g., if\n",
      "        you have a bunch of PostScript scripts that you want to run from\n",
      "        an interactive ipython session, you may want to switch to the PS\n",
      "        backend before running them to avoid having a bunch of GUI windows\n",
      "        popup.  If you try to interactively switch from one GUI backend to\n",
      "        another, you will explode.\n",
      "        \n",
      "        Calling this command will close all open windows.\n",
      "    \n",
      "    table(**kwargs)\n",
      "        Add a table to the current axes.\n",
      "        \n",
      "        Call signature::\n",
      "        \n",
      "          table(cellText=None, cellColours=None,\n",
      "                cellLoc='right', colWidths=None,\n",
      "                rowLabels=None, rowColours=None, rowLoc='left',\n",
      "                colLabels=None, colColours=None, colLoc='center',\n",
      "                loc='bottom', bbox=None):\n",
      "        \n",
      "        Returns a :class:`matplotlib.table.Table` instance. Either `cellText`\n",
      "        or `cellColours` must be provided. For finer grained control over\n",
      "        tables, use the :class:`~matplotlib.table.Table` class and add it to\n",
      "        the axes with :meth:`~matplotlib.axes.Axes.add_table`.\n",
      "        \n",
      "        Thanks to John Gill for providing the class and table.\n",
      "        \n",
      "        kwargs control the :class:`~matplotlib.table.Table`\n",
      "        properties:\n",
      "        \n",
      "          agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array \n",
      "          alpha: float (0.0 transparent through 1.0 opaque) \n",
      "          animated: bool \n",
      "          clip_box: a `~.Bbox` instance \n",
      "          clip_on: bool \n",
      "          clip_path: [(`~matplotlib.path.Path`, `~.Transform`) | `~.Patch` | None] \n",
      "          contains: a callable function \n",
      "          figure: a `~.Figure` instance \n",
      "          fontsize: a float in points \n",
      "          gid: an id string \n",
      "          label: object \n",
      "          path_effects: `~.AbstractPathEffect` \n",
      "          picker: [None | bool | float | callable] \n",
      "          rasterized: bool or None \n",
      "          sketch_params: (scale: float, length: float, randomness: float) \n",
      "          snap: bool or None \n",
      "          transform: `~.Transform` \n",
      "          url: a url string \n",
      "          visible: bool \n",
      "          zorder: float\n",
      "    \n",
      "    text(x, y, s, fontdict=None, withdash=False, **kwargs)\n",
      "        Add text to the axes.\n",
      "        \n",
      "        Add text in string `s` to axis at location `x`, `y`, data\n",
      "        coordinates.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x, y : scalars\n",
      "            data coordinates\n",
      "        \n",
      "        s : string\n",
      "            text\n",
      "        \n",
      "        fontdict : dictionary, optional, default: None\n",
      "            A dictionary to override the default text properties. If fontdict\n",
      "            is None, the defaults are determined by your rc parameters.\n",
      "        \n",
      "        withdash : boolean, optional, default: False\n",
      "            Creates a `~matplotlib.text.TextWithDash` instance instead of a\n",
      "            `~matplotlib.text.Text` instance.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.text.Text` properties.\n",
      "            Other miscellaneous text parameters.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Individual keyword arguments can be used to override any given\n",
      "        parameter::\n",
      "        \n",
      "            >>> text(x, y, s, fontsize=12)\n",
      "        \n",
      "        The default transform specifies that text is in data coords,\n",
      "        alternatively, you can specify text in axis coords (0,0 is\n",
      "        lower-left and 1,1 is upper-right).  The example below places\n",
      "        text in the center of the axes::\n",
      "        \n",
      "            >>> text(0.5, 0.5,'matplotlib', horizontalalignment='center',\n",
      "            ...      verticalalignment='center',\n",
      "            ...      transform=ax.transAxes)\n",
      "        \n",
      "        You can put a rectangular box around the text instance (e.g., to\n",
      "        set a background color) by using the keyword `bbox`.  `bbox` is\n",
      "        a dictionary of `~matplotlib.patches.Rectangle`\n",
      "        properties.  For example::\n",
      "        \n",
      "            >>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))\n",
      "    \n",
      "    thetagrids(*args, **kwargs)\n",
      "        Get or set the theta locations of the gridlines in a polar plot.\n",
      "        \n",
      "        If no arguments are passed, return a tuple (*lines*, *labels*)\n",
      "        where *lines* is an array of radial gridlines\n",
      "        (:class:`~matplotlib.lines.Line2D` instances) and *labels* is an\n",
      "        array of tick labels (:class:`~matplotlib.text.Text` instances)::\n",
      "        \n",
      "          lines, labels = thetagrids()\n",
      "        \n",
      "        Otherwise the syntax is::\n",
      "        \n",
      "          lines, labels = thetagrids(angles, labels=None, fmt='%d', frac = 1.1)\n",
      "        \n",
      "        set the angles at which to place the theta grids (these gridlines\n",
      "        are equal along the theta dimension).\n",
      "        \n",
      "        *angles* is in degrees.\n",
      "        \n",
      "        *labels*, if not *None*, is a len(angles) list of strings of the\n",
      "        labels to use at each angle.\n",
      "        \n",
      "        If *labels* is *None*, the labels will be ``fmt%angle``.\n",
      "        \n",
      "        *frac* is the fraction of the polar axes radius at which to place\n",
      "        the label (1 is the edge). e.g., 1.05 is outside the axes and 0.95\n",
      "        is inside the axes.\n",
      "        \n",
      "        Return value is a list of tuples (*lines*, *labels*):\n",
      "        \n",
      "          - *lines* are :class:`~matplotlib.lines.Line2D` instances\n",
      "        \n",
      "          - *labels* are :class:`~matplotlib.text.Text` instances.\n",
      "        \n",
      "        Note that on input, the *labels* argument is a list of strings,\n",
      "        and on output it is a list of :class:`~matplotlib.text.Text`\n",
      "        instances.\n",
      "        \n",
      "        Examples::\n",
      "        \n",
      "          # set the locations of the radial gridlines and labels\n",
      "          lines, labels = thetagrids( range(45,360,90) )\n",
      "        \n",
      "          # set the locations and labels of the radial gridlines and labels\n",
      "          lines, labels = thetagrids( range(45,360,90), ('NE', 'NW', 'SW','SE') )\n",
      "    \n",
      "    tick_params(axis='both', **kwargs)\n",
      "        Change the appearance of ticks and tick labels.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        axis : {'x', 'y', 'both'}, optional\n",
      "            Which axis to apply the parameters to.\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        \n",
      "        axis : {'x', 'y', 'both'}\n",
      "            Axis on which to operate; default is 'both'.\n",
      "        \n",
      "        reset : bool\n",
      "            If *True*, set all parameters to defaults\n",
      "            before processing other keyword arguments.  Default is\n",
      "            *False*.\n",
      "        \n",
      "        which : {'major', 'minor', 'both'}\n",
      "            Default is 'major'; apply arguments to *which* ticks.\n",
      "        \n",
      "        direction : {'in', 'out', 'inout'}\n",
      "            Puts ticks inside the axes, outside the axes, or both.\n",
      "        \n",
      "        length : float\n",
      "            Tick length in points.\n",
      "        \n",
      "        width : float\n",
      "            Tick width in points.\n",
      "        \n",
      "        color : color\n",
      "            Tick color; accepts any mpl color spec.\n",
      "        \n",
      "        pad : float\n",
      "            Distance in points between tick and label.\n",
      "        \n",
      "        labelsize : float or str\n",
      "            Tick label font size in points or as a string (e.g., 'large').\n",
      "        \n",
      "        labelcolor : color\n",
      "            Tick label color; mpl color spec.\n",
      "        \n",
      "        colors : color\n",
      "            Changes the tick color and the label color to the same value:\n",
      "            mpl color spec.\n",
      "        \n",
      "        zorder : float\n",
      "            Tick and label zorder.\n",
      "        \n",
      "        bottom, top, left, right : bool or  {'on', 'off'}\n",
      "            controls whether to draw the respective ticks.\n",
      "        \n",
      "        labelbottom, labeltop, labelleft, labelright : bool or  {'on', 'off'}\n",
      "            controls whether to draw the\n",
      "            respective tick labels.\n",
      "        \n",
      "        labelrotation : float\n",
      "            Tick label rotation\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        \n",
      "        Usage ::\n",
      "        \n",
      "            ax.tick_params(direction='out', length=6, width=2, colors='r')\n",
      "        \n",
      "        This will make all major ticks be red, pointing out of the box,\n",
      "        and with dimensions 6 points by 2 points.  Tick labels will\n",
      "        also be red.\n",
      "    \n",
      "    ticklabel_format(**kwargs)\n",
      "        Change the `~matplotlib.ticker.ScalarFormatter` used by\n",
      "        default for linear axes.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          ==============   =========================================\n",
      "          Keyword          Description\n",
      "          ==============   =========================================\n",
      "          *style*          [ 'sci' (or 'scientific') | 'plain' ]\n",
      "                           plain turns off scientific notation\n",
      "          *scilimits*      (m, n), pair of integers; if *style*\n",
      "                           is 'sci', scientific notation will\n",
      "                           be used for numbers outside the range\n",
      "                           10`m`:sup: to 10`n`:sup:.\n",
      "                           Use (0,0) to include all numbers.\n",
      "          *useOffset*      [True | False | offset]; if True,\n",
      "                           the offset will be calculated as needed;\n",
      "                           if False, no offset will be used; if a\n",
      "                           numeric offset is specified, it will be\n",
      "                           used.\n",
      "          *axis*           [ 'x' | 'y' | 'both' ]\n",
      "          *useLocale*      If True, format the number according to\n",
      "                           the current locale.  This affects things\n",
      "                           such as the character used for the\n",
      "                           decimal separator.  If False, use\n",
      "                           C-style (English) formatting.  The\n",
      "                           default setting is controlled by the\n",
      "                           axes.formatter.use_locale rcparam.\n",
      "          *useMathText*    If True, render the offset and scientific\n",
      "                           notation in mathtext\n",
      "          ==============   =========================================\n",
      "        \n",
      "        Only the major ticks are affected.\n",
      "        If the method is called when the\n",
      "        :class:`~matplotlib.ticker.ScalarFormatter` is not the\n",
      "        :class:`~matplotlib.ticker.Formatter` being used, an\n",
      "        :exc:`AttributeError` will be raised.\n",
      "    \n",
      "    tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None)\n",
      "        Automatically adjust subplot parameters to give specified padding.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        pad : float\n",
      "            padding between the figure edge and the edges of subplots, as a fraction of the font-size.\n",
      "        h_pad, w_pad : float\n",
      "            padding (height/width) between edges of adjacent subplots.\n",
      "            Defaults to `pad_inches`.\n",
      "        rect : if rect is given, it is interpreted as a rectangle\n",
      "            (left, bottom, right, top) in the normalized figure\n",
      "            coordinate that the whole subplots area (including\n",
      "            labels) will fit into. Default is (0, 0, 1, 1).\n",
      "    \n",
      "    title(s, *args, **kwargs)\n",
      "        Set a title of the current axes.\n",
      "        \n",
      "        Set one of the three available axes titles. The available titles are\n",
      "        positioned above the axes in the center, flush with the left edge,\n",
      "        and flush with the right edge.\n",
      "        \n",
      "        .. seealso::\n",
      "            See :func:`~matplotlib.pyplot.text` for adding text\n",
      "            to the current axes\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        label : str\n",
      "            Text to use for the title\n",
      "        \n",
      "        fontdict : dict\n",
      "            A dictionary controlling the appearance of the title text,\n",
      "            the default `fontdict` is:\n",
      "        \n",
      "                {'fontsize': rcParams['axes.titlesize'],\n",
      "                'fontweight' : rcParams['axes.titleweight'],\n",
      "                'verticalalignment': 'baseline',\n",
      "                'horizontalalignment': loc}\n",
      "        \n",
      "        loc : {'center', 'left', 'right'}, str, optional\n",
      "            Which title to set, defaults to 'center'\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        text : :class:`~matplotlib.text.Text`\n",
      "            The matplotlib text instance representing the title\n",
      "        \n",
      "        Other parameters\n",
      "        ----------------\n",
      "        kwargs : text properties\n",
      "            Other keyword arguments are text properties, see\n",
      "            :class:`~matplotlib.text.Text` for a list of valid text\n",
      "            properties.\n",
      "    \n",
      "    tricontour(*args, **kwargs)\n",
      "        Draw contours on an unstructured triangular grid.\n",
      "        :func:`~matplotlib.pyplot.tricontour` and\n",
      "        :func:`~matplotlib.pyplot.tricontourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "          tricontour(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(x, y, ...)\n",
      "          tricontour(x, y, triangles, ...)\n",
      "          tricontour(x, y, triangles=triangles, ...)\n",
      "          tricontour(x, y, mask=mask, ...)\n",
      "          tricontour(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of\n",
      "        these possibilities.\n",
      "        \n",
      "        The remaining arguments may be::\n",
      "        \n",
      "          tricontour(..., Z)\n",
      "        \n",
      "        where *Z* is the array of values to contour, one per point\n",
      "        in the triangulation.  The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(..., Z, N)\n",
      "        \n",
      "        contour *N* automatically-chosen levels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(..., Z, V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontourf(..., Z, V)\n",
      "        \n",
      "        fill the (len(*V*)-1) regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        ``C = tricontour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.TriContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *levels* [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is None, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        \n",
      "        tricontour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the 'solid' is used.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "            If contour is using a monochrome colormap and the contour\n",
      "            level is less than 0, then the linestyle specified\n",
      "            in ``contour.negative_linestyle`` in ``matplotlibrc``\n",
      "            will be used.\n",
      "        \n",
      "        tricontourf-only keyword arguments:\n",
      "        \n",
      "          *antialiased*: [ *True* | *False* ]\n",
      "            enable antialiasing\n",
      "        \n",
      "        Note: tricontourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    tricontourf(*args, **kwargs)\n",
      "        Draw contours on an unstructured triangular grid.\n",
      "        :func:`~matplotlib.pyplot.tricontour` and\n",
      "        :func:`~matplotlib.pyplot.tricontourf` draw contour lines and\n",
      "        filled contours, respectively.  Except as noted, function\n",
      "        signatures and return values are the same for both versions.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "          tricontour(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(x, y, ...)\n",
      "          tricontour(x, y, triangles, ...)\n",
      "          tricontour(x, y, triangles=triangles, ...)\n",
      "          tricontour(x, y, mask=mask, ...)\n",
      "          tricontour(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of\n",
      "        these possibilities.\n",
      "        \n",
      "        The remaining arguments may be::\n",
      "        \n",
      "          tricontour(..., Z)\n",
      "        \n",
      "        where *Z* is the array of values to contour, one per point\n",
      "        in the triangulation.  The level values are chosen\n",
      "        automatically.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(..., Z, N)\n",
      "        \n",
      "        contour *N* automatically-chosen levels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(..., Z, V)\n",
      "        \n",
      "        draw contour lines at the values specified in sequence *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontourf(..., Z, V)\n",
      "        \n",
      "        fill the (len(*V*)-1) regions between the values in *V*,\n",
      "        which must be in increasing order.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tricontour(Z, **kwargs)\n",
      "        \n",
      "        Use keyword args to control colors, linewidth, origin, cmap ... see\n",
      "        below for more details.\n",
      "        \n",
      "        ``C = tricontour(...)`` returns a\n",
      "        :class:`~matplotlib.contour.TriContourSet` object.\n",
      "        \n",
      "        Optional keyword arguments:\n",
      "        \n",
      "          *colors*: [ *None* | string | (mpl_colors) ]\n",
      "            If *None*, the colormap specified by cmap will be used.\n",
      "        \n",
      "            If a string, like 'r' or 'red', all levels will be plotted in this\n",
      "            color.\n",
      "        \n",
      "            If a tuple of matplotlib color args (string, float, rgb, etc),\n",
      "            different levels will be plotted in different colors in the order\n",
      "            specified.\n",
      "        \n",
      "          *alpha*: float\n",
      "            The alpha blending value\n",
      "        \n",
      "          *cmap*: [ *None* | Colormap ]\n",
      "            A cm :class:`~matplotlib.colors.Colormap` instance or\n",
      "            *None*. If *cmap* is *None* and *colors* is *None*, a\n",
      "            default Colormap is used.\n",
      "        \n",
      "          *norm*: [ *None* | Normalize ]\n",
      "            A :class:`matplotlib.colors.Normalize` instance for\n",
      "            scaling data values to colors. If *norm* is *None* and\n",
      "            *colors* is *None*, the default linear scaling is used.\n",
      "        \n",
      "          *levels* [level0, level1, ..., leveln]\n",
      "            A list of floating point numbers indicating the level\n",
      "            curves to draw, in increasing order; e.g., to draw just\n",
      "            the zero contour pass ``levels=[0]``\n",
      "        \n",
      "          *origin*: [ *None* | 'upper' | 'lower' | 'image' ]\n",
      "            If *None*, the first value of *Z* will correspond to the\n",
      "            lower left corner, location (0,0). If 'image', the rc\n",
      "            value for ``image.origin`` will be used.\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *extent*: [ *None* | (x0,x1,y0,y1) ]\n",
      "        \n",
      "            If *origin* is not *None*, then *extent* is interpreted as\n",
      "            in :func:`matplotlib.pyplot.imshow`: it gives the outer\n",
      "            pixel boundaries. In this case, the position of Z[0,0]\n",
      "            is the center of the pixel, not a corner. If *origin* is\n",
      "            *None*, then (*x0*, *y0*) is the position of Z[0,0], and\n",
      "            (*x1*, *y1*) is the position of Z[-1,-1].\n",
      "        \n",
      "            This keyword is not active if *X* and *Y* are specified in\n",
      "            the call to contour.\n",
      "        \n",
      "          *locator*: [ *None* | ticker.Locator subclass ]\n",
      "            If *locator* is None, the default\n",
      "            :class:`~matplotlib.ticker.MaxNLocator` is used. The\n",
      "            locator is used to determine the contour levels if they\n",
      "            are not given explicitly via the *V* argument.\n",
      "        \n",
      "          *extend*: [ 'neither' | 'both' | 'min' | 'max' ]\n",
      "            Unless this is 'neither', contour levels are automatically\n",
      "            added to one or both ends of the range so that all data\n",
      "            are included. These added ranges are then mapped to the\n",
      "            special colormap values which default to the ends of the\n",
      "            colormap range, but can be set via\n",
      "            :meth:`matplotlib.colors.Colormap.set_under` and\n",
      "            :meth:`matplotlib.colors.Colormap.set_over` methods.\n",
      "        \n",
      "          *xunits*, *yunits*: [ *None* | registered units ]\n",
      "            Override axis units by specifying an instance of a\n",
      "            :class:`matplotlib.units.ConversionInterface`.\n",
      "        \n",
      "        \n",
      "        tricontour-only keyword arguments:\n",
      "        \n",
      "          *linewidths*: [ *None* | number | tuple of numbers ]\n",
      "            If *linewidths* is *None*, the default width in\n",
      "            ``lines.linewidth`` in ``matplotlibrc`` is used.\n",
      "        \n",
      "            If a number, all levels will be plotted with this linewidth.\n",
      "        \n",
      "            If a tuple, different levels will be plotted with different\n",
      "            linewidths in the order specified\n",
      "        \n",
      "          *linestyles*: [ *None* | 'solid' | 'dashed' | 'dashdot' | 'dotted' ]\n",
      "            If *linestyles* is *None*, the 'solid' is used.\n",
      "        \n",
      "            *linestyles* can also be an iterable of the above strings\n",
      "            specifying a set of linestyles to be used. If this\n",
      "            iterable is shorter than the number of contour levels\n",
      "            it will be repeated as necessary.\n",
      "        \n",
      "            If contour is using a monochrome colormap and the contour\n",
      "            level is less than 0, then the linestyle specified\n",
      "            in ``contour.negative_linestyle`` in ``matplotlibrc``\n",
      "            will be used.\n",
      "        \n",
      "        tricontourf-only keyword arguments:\n",
      "        \n",
      "          *antialiased*: [ *True* | *False* ]\n",
      "            enable antialiasing\n",
      "        \n",
      "        Note: tricontourf fills intervals that are closed at the top; that\n",
      "        is, for boundaries *z1* and *z2*, the filled region is::\n",
      "        \n",
      "            z1 < z <= z2\n",
      "        \n",
      "        There is one exception: if the lowest boundary coincides with\n",
      "        the minimum value of the *z* array, then that minimum value\n",
      "        will be included in the lowest interval.\n",
      "    \n",
      "    tripcolor(*args, **kwargs)\n",
      "        Create a pseudocolor plot of an unstructured triangular grid.\n",
      "        \n",
      "        The triangulation can be specified in one of two ways; either::\n",
      "        \n",
      "          tripcolor(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          tripcolor(x, y, ...)\n",
      "          tripcolor(x, y, triangles, ...)\n",
      "          tripcolor(x, y, triangles=triangles, ...)\n",
      "          tripcolor(x, y, mask=mask, ...)\n",
      "          tripcolor(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of these\n",
      "        possibilities.\n",
      "        \n",
      "        The next argument must be *C*, the array of color values, either\n",
      "        one per point in the triangulation if color values are defined at\n",
      "        points, or one per triangle in the triangulation if color values\n",
      "        are defined at triangles. If there are the same number of points\n",
      "        and triangles in the triangulation it is assumed that color\n",
      "        values are defined at points; to force the use of color values at\n",
      "        triangles use the kwarg ``facecolors=C`` instead of just ``C``.\n",
      "        \n",
      "        *shading* may be 'flat' (the default) or 'gouraud'. If *shading*\n",
      "        is 'flat' and C values are defined at points, the color values\n",
      "        used for each triangle are from the mean C of the triangle's\n",
      "        three points. If *shading* is 'gouraud' then color values must be\n",
      "        defined at points.\n",
      "        \n",
      "        The remaining kwargs are the same as for\n",
      "        :meth:`~matplotlib.axes.Axes.pcolor`.\n",
      "    \n",
      "    triplot(*args, **kwargs)\n",
      "        Draw a unstructured triangular grid as lines and/or markers.\n",
      "        \n",
      "        The triangulation to plot can be specified in one of two ways;\n",
      "        either::\n",
      "        \n",
      "          triplot(triangulation, ...)\n",
      "        \n",
      "        where triangulation is a :class:`matplotlib.tri.Triangulation`\n",
      "        object, or\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          triplot(x, y, ...)\n",
      "          triplot(x, y, triangles, ...)\n",
      "          triplot(x, y, triangles=triangles, ...)\n",
      "          triplot(x, y, mask=mask, ...)\n",
      "          triplot(x, y, triangles, mask=mask, ...)\n",
      "        \n",
      "        in which case a Triangulation object will be created.  See\n",
      "        :class:`~matplotlib.tri.Triangulation` for a explanation of these\n",
      "        possibilities.\n",
      "        \n",
      "        The remaining args and kwargs are the same as for\n",
      "        :meth:`~matplotlib.axes.Axes.plot`.\n",
      "        \n",
      "        Return a list of 2 :class:`~matplotlib.lines.Line2D` containing\n",
      "        respectively:\n",
      "        \n",
      "            - the lines plotted for triangles edges\n",
      "            - the markers plotted for triangles nodes\n",
      "    \n",
      "    twinx(ax=None)\n",
      "        Make a second axes that shares the *x*-axis.  The new axes will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*).  The ticks\n",
      "        for *ax2* will be placed on the right, and the *ax2* instance is\n",
      "        returned.\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "           :file:`examples/api_examples/two_scales.py`\n",
      "              For an example\n",
      "    \n",
      "    twiny(ax=None)\n",
      "        Make a second axes that shares the *y*-axis.  The new axis will\n",
      "        overlay *ax* (or the current axes if *ax* is *None*).  The ticks\n",
      "        for *ax2* will be placed on the top, and the *ax2* instance is\n",
      "        returned.\n",
      "    \n",
      "    uninstall_repl_displayhook()\n",
      "        Uninstalls the matplotlib display hook.\n",
      "        \n",
      "        .. warning\n",
      "        \n",
      "           Need IPython >= 2 for this to work.  For IPython < 2 will raise a\n",
      "           ``NotImplementedError``\n",
      "        \n",
      "        .. warning\n",
      "        \n",
      "           If you are using vanilla python and have installed another\n",
      "           display hook this will reset ``sys.displayhook`` to what ever\n",
      "           function was there when matplotlib installed it's displayhook,\n",
      "           possibly discarding your changes.\n",
      "    \n",
      "    violinplot(dataset, positions=None, vert=True, widths=0.5, showmeans=False, showextrema=True, showmedians=False, points=100, bw_method=None, hold=None, data=None)\n",
      "        Make a violin plot.\n",
      "        \n",
      "        Make a violin plot for each column of *dataset* or each vector in\n",
      "        sequence *dataset*.  Each filled area extends to represent the\n",
      "        entire data range, with optional lines at the mean, the median,\n",
      "        the minimum, and the maximum.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        dataset : Array or a sequence of vectors.\n",
      "          The input data.\n",
      "        \n",
      "        positions : array-like, default = [1, 2, ..., n]\n",
      "          Sets the positions of the violins. The ticks and limits are\n",
      "          automatically set to match the positions.\n",
      "        \n",
      "        vert : bool, default = True.\n",
      "          If true, creates a vertical violin plot.\n",
      "          Otherwise, creates a horizontal violin plot.\n",
      "        \n",
      "        widths : array-like, default = 0.5\n",
      "          Either a scalar or a vector that sets the maximal width of\n",
      "          each violin. The default is 0.5, which uses about half of the\n",
      "          available horizontal space.\n",
      "        \n",
      "        showmeans : bool, default = False\n",
      "          If `True`, will toggle rendering of the means.\n",
      "        \n",
      "        showextrema : bool, default = True\n",
      "          If `True`, will toggle rendering of the extrema.\n",
      "        \n",
      "        showmedians : bool, default = False\n",
      "          If `True`, will toggle rendering of the medians.\n",
      "        \n",
      "        points : scalar, default = 100\n",
      "          Defines the number of points to evaluate each of the\n",
      "          gaussian kernel density estimations at.\n",
      "        \n",
      "        bw_method : str, scalar or callable, optional\n",
      "          The method used to calculate the estimator bandwidth.  This can be\n",
      "          'scott', 'silverman', a scalar constant or a callable.  If a\n",
      "          scalar, this will be used directly as `kde.factor`.  If a\n",
      "          callable, it should take a `GaussianKDE` instance as its only\n",
      "          parameter and return a scalar. If None (default), 'scott' is used.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        \n",
      "        result : dict\n",
      "          A dictionary mapping each component of the violinplot to a\n",
      "          list of the corresponding collection instances created. The\n",
      "          dictionary has the following keys:\n",
      "        \n",
      "            - ``bodies``: A list of the\n",
      "              :class:`matplotlib.collections.PolyCollection` instances\n",
      "              containing the filled area of each violin.\n",
      "        \n",
      "            - ``cmeans``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the mean values of each of the\n",
      "              violin's distribution.\n",
      "        \n",
      "            - ``cmins``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the bottom of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cmaxes``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the top of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cbars``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the centers of each violin's\n",
      "              distribution.\n",
      "        \n",
      "            - ``cmedians``: A\n",
      "              :class:`matplotlib.collections.LineCollection` instance\n",
      "              created to identify the median values of each of the\n",
      "              violin's distribution.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'dataset'.\n",
      "    \n",
      "    viridis()\n",
      "        set the default colormap to viridis and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    vlines(x, ymin, ymax, colors='k', linestyles='solid', label='', hold=None, data=None, **kwargs)\n",
      "        Plot vertical lines.\n",
      "        \n",
      "        Plot vertical lines at each `x` from `ymin` to `ymax`.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : scalar or 1D array_like\n",
      "            x-indexes where to plot the lines.\n",
      "        \n",
      "        ymin, ymax : scalar or 1D array_like\n",
      "            Respective beginning and end of each line. If scalars are\n",
      "            provided, all lines will have same length.\n",
      "        \n",
      "        colors : array_like of colors, optional, default: 'k'\n",
      "        \n",
      "        linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional\n",
      "        \n",
      "        label : string, optional, default: ''\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        lines : `~matplotlib.collections.LineCollection`\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        **kwargs : `~matplotlib.collections.LineCollection` properties.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        hlines : horizontal lines\n",
      "        axvline: vertical line across the axes\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'colors', 'x', 'ymax', 'ymin'.\n",
      "    \n",
      "    waitforbuttonpress(*args, **kwargs)\n",
      "        Blocking call to interact with the figure.\n",
      "        \n",
      "        This will return True is a key was pressed, False if a mouse\n",
      "        button was pressed and None if *timeout* was reached without\n",
      "        either being pressed.\n",
      "        \n",
      "        If *timeout* is negative, does not timeout.\n",
      "    \n",
      "    winter()\n",
      "        set the default colormap to winter and apply to current image if any.\n",
      "        See help(colormaps) for more information\n",
      "    \n",
      "    xcorr(x, y, normed=True, detrend=<function detrend_none at 0xac9008e8>, usevlines=True, maxlags=10, hold=None, data=None, **kwargs)\n",
      "        Plot the cross correlation between *x* and *y*.\n",
      "        \n",
      "        The correlation with lag k is defined as sum_n x[n+k] * conj(y[n]).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        \n",
      "        x : sequence of scalars of length n\n",
      "        \n",
      "        y : sequence of scalars of length n\n",
      "        \n",
      "        hold : boolean, optional, *deprecated*, default: True\n",
      "        \n",
      "        detrend : callable, optional, default: `mlab.detrend_none`\n",
      "            x is detrended by the `detrend` callable. Default is no\n",
      "            normalization.\n",
      "        \n",
      "        normed : boolean, optional, default: True\n",
      "            if True, input vectors are normalised to unit length.\n",
      "        \n",
      "        usevlines : boolean, optional, default: True\n",
      "            if True, Axes.vlines is used to plot the vertical lines from the\n",
      "            origin to the acorr. Otherwise, Axes.plot is used.\n",
      "        \n",
      "        maxlags : integer, optional, default: 10\n",
      "            number of lags to show. If None, will return all 2 * len(x) - 1\n",
      "            lags.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        (lags, c, line, b) : where:\n",
      "        \n",
      "          - `lags` are a length 2`maxlags+1 lag vector.\n",
      "          - `c` is the 2`maxlags+1 auto correlation vectorI\n",
      "          - `line` is a `~matplotlib.lines.Line2D` instance returned by\n",
      "            `plot`.\n",
      "          - `b` is the x-axis (none, if plot is used).\n",
      "        \n",
      "        Other Parameters\n",
      "        ----------------\n",
      "        linestyle : `~matplotlib.lines.Line2D` prop, optional, default: None\n",
      "            Only used if usevlines is False.\n",
      "        \n",
      "        marker : string, optional, default: 'o'\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The cross correlation is performed with :func:`numpy.correlate` with\n",
      "        `mode` = 2.\n",
      "        \n",
      "        .. note::\n",
      "            In addition to the above described arguments, this function can take a\n",
      "            **data** keyword argument. If such a **data** argument is given, the\n",
      "            following arguments are replaced by **data[<arg>]**:\n",
      "        \n",
      "            * All arguments with the following names: 'x', 'y'.\n",
      "    \n",
      "    xkcd(scale=1, length=100, randomness=2)\n",
      "        Turns on `xkcd <https://xkcd.com/>`_ sketch-style drawing mode.\n",
      "        This will only have effect on things drawn after this function is\n",
      "        called.\n",
      "        \n",
      "        For best results, the \"Humor Sans\" font should be installed: it is\n",
      "        not included with matplotlib.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        scale : float, optional\n",
      "            The amplitude of the wiggle perpendicular to the source line.\n",
      "        length : float, optional\n",
      "            The length of the wiggle along the line.\n",
      "        randomness : float, optional\n",
      "            The scale factor by which the length is shrunken or expanded.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function works by a number of rcParams, so it will probably\n",
      "        override others you have set before.\n",
      "        \n",
      "        If you want the effects of this function to be temporary, it can\n",
      "        be used as a context manager, for example::\n",
      "        \n",
      "            with plt.xkcd():\n",
      "                # This figure will be in XKCD-style\n",
      "                fig1 = plt.figure()\n",
      "                # ...\n",
      "        \n",
      "            # This figure will be in regular style\n",
      "            fig2 = plt.figure()\n",
      "    \n",
      "    xlabel(s, *args, **kwargs)\n",
      "        Set the *x* axis label of the current axis.\n",
      "        \n",
      "        Default override is::\n",
      "        \n",
      "          override = {\n",
      "              'fontsize'            : 'small',\n",
      "              'verticalalignment'   : 'top',\n",
      "              'horizontalalignment' : 'center'\n",
      "              }\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`~matplotlib.pyplot.text`\n",
      "                For information on how override and the optional args work\n",
      "    \n",
      "    xlim(*args, **kwargs)\n",
      "        Get or set the *x* limits of the current axes.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          xmin, xmax = xlim()   # return the current xlim\n",
      "          xlim( (xmin, xmax) )  # set the xlim to xmin, xmax\n",
      "          xlim( xmin, xmax )    # set the xlim to xmin, xmax\n",
      "        \n",
      "        If you do not specify args, you can pass the xmin and xmax as\n",
      "        kwargs, e.g.::\n",
      "        \n",
      "          xlim(xmax=3) # adjust the max leaving min unchanged\n",
      "          xlim(xmin=1) # adjust the min leaving max unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the x-axis.\n",
      "        \n",
      "        The new axis limits are returned as a length 2 tuple.\n",
      "    \n",
      "    xscale(*args, **kwargs)\n",
      "        Set the scaling of the *x*-axis.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          xscale(scale, **kwargs)\n",
      "        \n",
      "        The available scales are: 'linear' | 'log' | 'logit' | 'symlog'\n",
      "        \n",
      "        Different keywords may be accepted, depending on the scale:\n",
      "        \n",
      "            'linear'\n",
      "        \n",
      "                \n",
      "        \n",
      "        \n",
      "            'log'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *nonposx*/*nonposy*: ['mask' | 'clip' ]\n",
      "                  non-positive values in *x* or *y* can be masked as\n",
      "                  invalid, or clipped to a very small positive number\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "        \n",
      "        \n",
      "            'logit'\n",
      "        \n",
      "                *nonpos*: ['mask' | 'clip' ]\n",
      "                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number\n",
      "                  very close to 0 or 1\n",
      "        \n",
      "        \n",
      "            'symlog'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *linthreshx*/*linthreshy*:\n",
      "                  A single float which defines the range (-*x*, *x*), within\n",
      "                  which the plot is linear. This avoids having the plot go to\n",
      "                  infinity around zero.\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "                \n",
      "                *linscalex*/*linscaley*:\n",
      "                   This allows the linear range (-*linthresh* to *linthresh*)\n",
      "                   to be stretched relative to the logarithmic range.  Its\n",
      "                   value is the number of decades to use for each half of the\n",
      "                   linear range.  For example, when *linscale* == 1.0 (the\n",
      "                   default), the space used for the positive and negative\n",
      "                   halves of the linear range will be equal to one decade in\n",
      "                   the logarithmic range.\n",
      "    \n",
      "    xticks(*args, **kwargs)\n",
      "        Get or set the *x*-limits of the current tick locations and labels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          # return locs, labels where locs is an array of tick locations and\n",
      "          # labels is an array of tick labels.\n",
      "          locs, labels = xticks()\n",
      "        \n",
      "          # set the locations of the xticks\n",
      "          xticks( arange(6) )\n",
      "        \n",
      "          # set the locations and labels of the xticks\n",
      "          xticks( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )\n",
      "        \n",
      "        The keyword args, if any, are :class:`~matplotlib.text.Text`\n",
      "        properties. For example, to rotate long labels::\n",
      "        \n",
      "          xticks( arange(12), calendar.month_name[1:13], rotation=17 )\n",
      "    \n",
      "    ylabel(s, *args, **kwargs)\n",
      "        Set the *y* axis label of the current axis.\n",
      "        \n",
      "        Defaults override is::\n",
      "        \n",
      "            override = {\n",
      "               'fontsize'            : 'small',\n",
      "               'verticalalignment'   : 'center',\n",
      "               'horizontalalignment' : 'right',\n",
      "               'rotation'='vertical' : }\n",
      "        \n",
      "        .. seealso::\n",
      "        \n",
      "            :func:`~matplotlib.pyplot.text`\n",
      "                For information on how override and the optional args\n",
      "                work.\n",
      "    \n",
      "    ylim(*args, **kwargs)\n",
      "        Get or set the *y*-limits of the current axes.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          ymin, ymax = ylim()   # return the current ylim\n",
      "          ylim( (ymin, ymax) )  # set the ylim to ymin, ymax\n",
      "          ylim( ymin, ymax )    # set the ylim to ymin, ymax\n",
      "        \n",
      "        If you do not specify args, you can pass the *ymin* and *ymax* as\n",
      "        kwargs, e.g.::\n",
      "        \n",
      "          ylim(ymax=3) # adjust the max leaving min unchanged\n",
      "          ylim(ymin=1) # adjust the min leaving max unchanged\n",
      "        \n",
      "        Setting limits turns autoscaling off for the y-axis.\n",
      "        \n",
      "        The new axis limits are returned as a length 2 tuple.\n",
      "    \n",
      "    yscale(*args, **kwargs)\n",
      "        Set the scaling of the *y*-axis.\n",
      "        \n",
      "        call signature::\n",
      "        \n",
      "          yscale(scale, **kwargs)\n",
      "        \n",
      "        The available scales are: 'linear' | 'log' | 'logit' | 'symlog'\n",
      "        \n",
      "        Different keywords may be accepted, depending on the scale:\n",
      "        \n",
      "            'linear'\n",
      "        \n",
      "                \n",
      "        \n",
      "        \n",
      "            'log'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *nonposx*/*nonposy*: ['mask' | 'clip' ]\n",
      "                  non-positive values in *x* or *y* can be masked as\n",
      "                  invalid, or clipped to a very small positive number\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "        \n",
      "        \n",
      "            'logit'\n",
      "        \n",
      "                *nonpos*: ['mask' | 'clip' ]\n",
      "                  values beyond ]0, 1[ can be masked as invalid, or clipped to a number\n",
      "                  very close to 0 or 1\n",
      "        \n",
      "        \n",
      "            'symlog'\n",
      "        \n",
      "                *basex*/*basey*:\n",
      "                   The base of the logarithm\n",
      "                \n",
      "                *linthreshx*/*linthreshy*:\n",
      "                  A single float which defines the range (-*x*, *x*), within\n",
      "                  which the plot is linear. This avoids having the plot go to\n",
      "                  infinity around zero.\n",
      "                \n",
      "                *subsx*/*subsy*:\n",
      "                   Where to place the subticks between each major tick.\n",
      "                   Should be a sequence of integers.  For example, in a log10\n",
      "                   scale: ``[2, 3, 4, 5, 6, 7, 8, 9]``\n",
      "                \n",
      "                   will place 8 logarithmically spaced minor ticks between\n",
      "                   each major tick.\n",
      "                \n",
      "                *linscalex*/*linscaley*:\n",
      "                   This allows the linear range (-*linthresh* to *linthresh*)\n",
      "                   to be stretched relative to the logarithmic range.  Its\n",
      "                   value is the number of decades to use for each half of the\n",
      "                   linear range.  For example, when *linscale* == 1.0 (the\n",
      "                   default), the space used for the positive and negative\n",
      "                   halves of the linear range will be equal to one decade in\n",
      "                   the logarithmic range.\n",
      "    \n",
      "    yticks(*args, **kwargs)\n",
      "        Get or set the *y*-limits of the current tick locations and labels.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "          # return locs, labels where locs is an array of tick locations and\n",
      "          # labels is an array of tick labels.\n",
      "          locs, labels = yticks()\n",
      "        \n",
      "          # set the locations of the yticks\n",
      "          yticks( arange(6) )\n",
      "        \n",
      "          # set the locations and labels of the yticks\n",
      "          yticks( arange(5), ('Tom', 'Dick', 'Harry', 'Sally', 'Sue') )\n",
      "        \n",
      "        The keyword args, if any, are :class:`~matplotlib.text.Text`\n",
      "        properties. For example, to rotate long labels::\n",
      "        \n",
      "          yticks( arange(12), calendar.month_name[1:13], rotation=45 )\n",
      "\n",
      "DATA\n",
      "    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...\n",
      "    division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...\n",
      "    print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...\n",
      "    rcParams = RcParams({'_internal.classic_mode': False,\n",
      "         ...nor.widt...\n",
      "    rcParamsDefault = RcParams({'_internal.classic_mode': False,\n",
      "         ...n...\n",
      "    unicode_literals = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', ...\n",
      "\n",
      "FILE\n",
      "    /usr/lib/python3/dist-packages/matplotlib/pyplot.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
